/*- * ============LICENSE_START======================================================= * SDC * ================================================================================ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ============LICENSE_END========================================================= */ package org.openecomp.sdc.be.components.impl; import com.google.common.collect.Sets; import com.google.gson.Gson; import fj.data.Either; import org.apache.commons.codec.binary.Base64; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic; import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum; import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo; import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum; import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum; import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaTagNamesEnum; import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic; import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction; import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction.LifecycleChanceActionEnum; import org.openecomp.sdc.be.components.merge.resource.MergeResourceBLFactory; import org.openecomp.sdc.be.components.merge.resource.MergeResourceBusinessLogic; import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum; import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils; import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter; import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition; import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.impl.WebAppContextWrapper; import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts; import org.openecomp.sdc.be.model.ArtifactDefinition; import org.openecomp.sdc.be.model.CapabilityDefinition; import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.ComponentInstance; import org.openecomp.sdc.be.model.ComponentInstanceInput; import org.openecomp.sdc.be.model.ComponentInstanceProperty; import org.openecomp.sdc.be.model.ComponentParametersView; import org.openecomp.sdc.be.model.CsarInfo; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.GroupDefinition; import org.openecomp.sdc.be.model.GroupProperty; import org.openecomp.sdc.be.model.GroupTypeDefinition; import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.LifeCycleTransitionEnum; import org.openecomp.sdc.be.model.LifecycleStateEnum; import org.openecomp.sdc.be.model.NodeTypeInfo; import org.openecomp.sdc.be.model.Operation; import org.openecomp.sdc.be.model.ParsedToscaYamlInfo; import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.RelationshipImpl; import org.openecomp.sdc.be.model.RelationshipInfo; import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; import org.openecomp.sdc.be.model.RequirementDefinition; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.UploadCapInfo; import org.openecomp.sdc.be.model.UploadComponentInstanceInfo; import org.openecomp.sdc.be.model.UploadPropInfo; import org.openecomp.sdc.be.model.UploadReqInfo; import org.openecomp.sdc.be.model.UploadResourceInfo; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; import org.openecomp.sdc.be.model.category.CategoryDefinition; import org.openecomp.sdc.be.model.category.SubCategoryDefinition; import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation; import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils; import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation; import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation; import org.openecomp.sdc.be.model.operations.api.IElementOperation; import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation; import org.openecomp.sdc.be.model.operations.api.IPropertyOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.CsarOperation; import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils; import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; import org.openecomp.sdc.be.resources.data.auditing.model.ResourceAuditData; import org.openecomp.sdc.be.tosca.CsarUtils; import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo; import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer; import org.openecomp.sdc.be.user.IUserBusinessLogic; import org.openecomp.sdc.be.user.Role; import org.openecomp.sdc.be.user.UserBusinessLogic; import org.openecomp.sdc.be.utils.CommonBeUtils; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import org.openecomp.sdc.common.api.Constants; import org.openecomp.sdc.common.datastructure.FunctionalInterfaces; import org.openecomp.sdc.common.datastructure.Wrapper; import org.openecomp.sdc.common.kpi.api.ASDCKpiApi; import org.openecomp.sdc.common.util.GeneralUtility; import org.openecomp.sdc.common.util.ValidationUtils; import org.openecomp.sdc.exception.ResponseFormat; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.context.WebApplicationContext; import org.yaml.snakeyaml.DumperOptions; import org.yaml.snakeyaml.Yaml; import org.yaml.snakeyaml.parser.ParserException; import javax.servlet.ServletContext; import java.util.ArrayList; import java.util.Collection; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Optional; import java.util.Set; import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN; @org.springframework.stereotype.Component("resourceBusinessLogic") public class ResourceBusinessLogic extends ComponentBusinessLogic { private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes"; public static final String INITIAL_VERSION = "0.1"; private Pattern STR_REPLACE_PATTERN = Pattern.compile("^[ ]*\\{[ ]*" + "str_replace" + "="); private Pattern TOKEN_PATTERN = Pattern.compile("[ ]*\\{[ ]*" + "token" + "="); private Pattern GET_PROPERTY_PATTERN = Pattern.compile("[ ]*\\{[ ]*" + "get_property" + "="); private Pattern CONCAT_PATTERN = Pattern.compile("[ ]*\\{[ ]*" + "concat" + "="); private Pattern GET_ATTRIBUTE_PATTERN = Pattern.compile("[ ]*\\{[ ]*" + "get_attribute" + "="); private static final Logger log = LoggerFactory.getLogger(ResourceBusinessLogic.class); private static Pattern pattern = Pattern.compile("\\..(.*?)\\.."); /** * Default constructor */ public ResourceBusinessLogic() { log.debug("ResourceBusinessLogic started"); } @Autowired private ICapabilityTypeOperation capabilityTypeOperation = null; @Autowired private IInterfaceLifecycleOperation interfaceTypeOperation = null; @Autowired private LifecycleBusinessLogic lifecycleBusinessLogic; @Autowired private IPropertyOperation propertyOperation; @Autowired private CsarOperation csarOperation; @Autowired private ComponentInstanceBusinessLogic componentInstanceBusinessLogic; @Autowired private ResourceImportManager resourceImportManager; @Autowired private InputsBusinessLogic inputsBusinessLogic; @Autowired private CompositionBusinessLogic compositionBusinessLogic; @Autowired private ICacheMangerOperation cacheManagerOperation; @Autowired private ApplicationDataTypeCache dataTypeCache; @Autowired private MergeResourceBLFactory mergeResourceBLFactory; @Autowired private CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic; @Autowired private InterfaceOperation interfaceOperation; private Gson gson = new Gson(); public void setInterfaceOperation(InterfaceOperation interfaceOperation) { this.interfaceOperation = interfaceOperation; } public CsarOperation getCsarOperation() { return csarOperation; } public void setCsarOperation(CsarOperation csarOperation) { this.csarOperation = csarOperation; } public LifecycleBusinessLogic getLifecycleBusinessLogic() { return lifecycleBusinessLogic; } public void setLifecycleManager(LifecycleBusinessLogic lifecycleBusinessLogic) { this.lifecycleBusinessLogic = lifecycleBusinessLogic; } public IElementOperation getElementDao() { return elementDao; } public void setElementDao(IElementOperation elementDao) { this.elementDao = elementDao; } public IUserBusinessLogic getUserAdmin() { return this.userAdmin; } public void setUserAdmin(UserBusinessLogic userAdmin) { this.userAdmin = userAdmin; } public ComponentsUtils getComponentsUtils() { return this.componentsUtils; } public void setComponentsUtils(ComponentsUtils componentsUtils) { this.componentsUtils = componentsUtils; } public ArtifactsBusinessLogic getArtifactsManager() { return artifactsBusinessLogic; } public void setArtifactsManager(ArtifactsBusinessLogic artifactsManager) { this.artifactsBusinessLogic = artifactsManager; } public void setPropertyOperation(IPropertyOperation propertyOperation) { this.propertyOperation = propertyOperation; } public ApplicationDataTypeCache getApplicationDataTypeCache() { return applicationDataTypeCache; } public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) { this.applicationDataTypeCache = applicationDataTypeCache; } public void setInterfaceTypeOperation(IInterfaceLifecycleOperation interfaceTypeOperation) { this.interfaceTypeOperation = interfaceTypeOperation; } /** * the method returns a list of all the resources that are certified, the * returned resources are only abstract or only none abstract according to * the given param * * @param getAbstract * @param userId TODO * @return */ public Either, ResponseFormat> getAllCertifiedResources(boolean getAbstract, HighestFilterEnum highestFilter, String userId) { Either resp = validateUserExists(userId, "get All Certified Resources", false); if (resp.isRight()) { return Either.right(resp.right().value()); } Boolean isHighest = null; switch (highestFilter) { case ALL: break; case HIGHEST_ONLY: isHighest = true; break; case NON_HIGHEST_ONLY: isHighest = false; break; default: break; } Either, StorageOperationStatus> getResponse = toscaOperationFacade .getAllCertifiedResources(getAbstract, isHighest); if (getResponse.isRight()) { return Either.right(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(getResponse.right().value()))); } return Either.left(getResponse.left().value()); } public Either, ResponseFormat> validateResourceNameExists(String resourceName, ResourceTypeEnum resourceTypeEnum, String userId) { Either resp = validateUserExists(userId, "validate Resource Name Exists", false); if (resp.isRight()) { return Either.right(resp.right().value()); } Either dataModelResponse = toscaOperationFacade .validateComponentNameUniqueness(resourceName, resourceTypeEnum, ComponentTypeEnum.RESOURCE); // DE242223 titanDao.commit(); if (dataModelResponse.isLeft()) { Map result = new HashMap<>(); result.put("isValid", dataModelResponse.left().value()); log.debug("validation was successfully performed."); return Either.left(result); } ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value())); return Either.right(responseFormat); } public Either createResource(Resource resource, AuditingActionEnum auditingAction, User user, Map csarUIPayload, String payloadName) { Either createResourceResponse = validateResourceBeforeCreate(resource, user, false); if (createResourceResponse.isRight()) { return createResourceResponse; } // Creating resource either by DAO or from CSAR String csarUUID = null; if (payloadName == null) { csarUUID = resource.getCsarUUID(); } else { csarUUID = payloadName; } if (csarUUID != null && !csarUUID.isEmpty()) { // check if VF with the same Csar UUID or with he same name already // exists Either validateCsarUuidUniquenessRes = toscaOperationFacade .validateCsarUuidUniqueness(csarUUID); if (validateCsarUuidUniquenessRes.isRight()) { log.debug("Failed to validate uniqueness of CsarUUID {} for resource", csarUUID, resource.getSystemName()); return Either.right(componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(validateCsarUuidUniquenessRes.right().value()))); } Integer existingResourceRes = validateCsarUuidUniquenessRes.left().value(); if (existingResourceRes.intValue() > 0) { log.debug("Failed to create resource {}, csarUUID {} already exist for a different VF ", resource.getSystemName(), csarUUID); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VSP_ALREADY_EXISTS, csarUUID); componentsUtils.auditResource(errorResponse, user, resource, auditingAction); return Either.right(errorResponse); } log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID); createResourceResponse = createResourceFromCsar(resource, user, Either.left(csarUIPayload), csarUUID); return createResourceResponse; } return createResourceByDao(resource, user, auditingAction, false, false); } public Either validateAndUpdateResourceFromCsar(Resource resource, User user, Map csarUIPayload, String payloadName, String resourceUniqueId) { Either updateResourceResponse = null; Either validateResourceResponse = null; Wrapper responseWrapper = new Wrapper(); String csarUUID = null; String csarVersion = null; if (payloadName == null) { csarUUID = resource.getCsarUUID(); csarVersion = resource.getCsarVersion(); } else { csarUUID = payloadName; } if (csarUUID != null && !csarUUID.isEmpty()) { Resource oldResource = getResourceByUniqueId(responseWrapper, resourceUniqueId); if (responseWrapper.isEmpty()) { validateCsarUuidMatching(responseWrapper, oldResource, resource, csarUUID, resourceUniqueId, user); } if (responseWrapper.isEmpty()) { validateCsarIsNotAlreadyUsed(responseWrapper, oldResource, resource, csarUUID, user); } if (responseWrapper.isEmpty()) { if (oldResource != null && ValidationUtils.hasBeenCertified(oldResource.getVersion())) { overrideImmutableMetadata(oldResource, resource); } validateResourceResponse = validateResourceBeforeCreate(resource, user, false); if (validateResourceResponse.isRight()) { responseWrapper.setInnerElement(validateResourceResponse.right().value()); } } if (responseWrapper.isEmpty()) { String oldCsarVersion = oldResource.getCsarVersion(); log.debug("CsarUUID is {} - going to update resource with UniqueId {} from CSAR", csarUUID, resourceUniqueId); // (on boarding flow): If the update includes same csarUUID and // same csarVersion as already in the VF - no need to import the // csar (do only metadata changes if there are). if (csarVersion != null && oldCsarVersion != null && oldCsarVersion.equals(csarVersion)) { updateResourceResponse = updateResourceMetadata(resourceUniqueId, resource, oldResource, user, false); } else { updateResourceResponse = updateResourceFromCsar(oldResource, resource, user, AuditingActionEnum.UPDATE_RESOURCE_METADATA, false, Either.left(csarUIPayload), csarUUID); } } } else { log.debug("Failed to update resource {}, csarUUID or payload name is missing", resource.getSystemName()); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CSAR_UUID, resource.getName()); componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.CREATE_RESOURCE); responseWrapper.setInnerElement(errorResponse); } if (responseWrapper.isEmpty()) { return updateResourceResponse; } return Either.right(responseWrapper.getInnerElement()); } private void validateCsarIsNotAlreadyUsed(Wrapper responseWrapper, Resource oldResource, Resource resource, String csarUUID, User user) { // (on boarding flow): If the update includes a csarUUID: verify this // csarUUID is not in use by another VF, If it is - use same error as // above: // "Error: The VSP with UUID %1 was already imported for VF %2. Please // select another or update the existing VF." %1 - csarUUID, %2 - VF // name Either resourceLinkedToCsarRes = toscaOperationFacade .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUUID, resource.getSystemName()); if (resourceLinkedToCsarRes.isRight()) { if (!StorageOperationStatus.NOT_FOUND.equals(resourceLinkedToCsarRes.right().value())) { log.debug("Failed to find previous resource by CSAR {} and system name {}", csarUUID, resource.getSystemName()); responseWrapper.setInnerElement(componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(resourceLinkedToCsarRes.right().value()))); } } else if (!resourceLinkedToCsarRes.left().value().getUniqueId().equals(oldResource.getUniqueId()) && !resourceLinkedToCsarRes.left().value().getName().equals(oldResource.getName())) { ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VSP_ALREADY_EXISTS, csarUUID, resourceLinkedToCsarRes.left().value().getName()); componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA); responseWrapper.setInnerElement(errorResponse); } } private void validateCsarUuidMatching(Wrapper responseWrapper, Resource resource, Resource oldResource, String csarUUID, String resourceUniqueId, User user) { // (on boarding flow): If the update includes csarUUID which is // different from the csarUUID of the VF - fail with // error: "Error: Resource %1 cannot be updated using since it is linked // to a different VSP" %1 - VF name String oldCsarUUID = oldResource.getCsarUUID(); if (oldCsarUUID != null && !oldCsarUUID.isEmpty() && !csarUUID.equals(oldCsarUUID)) { log.debug( "Failed to update resource with UniqueId {} using Csar {}, since the resource is linked to a different VSP {}", resourceUniqueId, csarUUID, oldCsarUUID); ResponseFormat errorResponse = componentsUtils.getResponseFormat( ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID, oldCsarUUID); componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA); responseWrapper.setInnerElement(errorResponse); } } private Resource getResourceByUniqueId(Wrapper responseWrapper, String resourceUniqueId) { Either oldResourceRes = toscaOperationFacade.getToscaFullElement(resourceUniqueId); if (oldResourceRes.isRight()) { log.debug("Failed to find previous resource by UniqueId {}, status: {}", resourceUniqueId, oldResourceRes.right().value()); responseWrapper.setInnerElement(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(oldResourceRes.right().value()))); return null; } return oldResourceRes.left().value(); } private void overrideImmutableMetadata(Resource oldRresource, Resource resource) { resource.setName(oldRresource.getName()); resource.setIcon(oldRresource.getIcon()); resource.setTags(oldRresource.getTags()); resource.setVendorName(oldRresource.getVendorName()); resource.setCategories(oldRresource.getCategories()); resource.setDerivedFrom(oldRresource.getDerivedFrom()); } private Either updateResourceFromCsar(Resource oldRresource, Resource newRresource, User user, AuditingActionEnum updateResource, boolean inTransaction, Either, StorageOperationStatus> csarUIPayload, String csarUUID) { // check state if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.equals(oldRresource.getLifecycleState())) { if (!oldRresource.getLastUpdaterUserId().equals(user.getUserId())) { log.debug("Current user is not last updater, last updater userId: {}, current user userId: {}", oldRresource.getLastUpdaterUserId(), user.getUserId()); return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)); } } String lockedResourceId = oldRresource.getUniqueId(); List createdArtifacts = new ArrayList<>(); Either, StorageOperationStatus> csar = null; if (csarUIPayload != null && csarUIPayload.left() != null && csarUIPayload.left().value() != null) { csar = csarUIPayload; } else { csar = csarOperation.getCsar(csarUUID, user); } if (csar.isRight()) { log.debug("Failed to get csar for casrUUID{} ", csarUUID); return Either.right(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(csar.right().value()))); } Either, ResponseFormat> toscaYamlCsarStatus = validateAndParseCsar(newRresource, user, csarUUID, csar); if (toscaYamlCsarStatus.isRight()) { return Either.right(toscaYamlCsarStatus.right().value()); } Either checksum = CsarValidationUtils.getToscaYamlChecksum(csar.left().value(), csarUUID, componentsUtils); if (checksum.isRight()) { log.debug("Failed to calculate checksum for casrUUID{} error {} ", csarUUID, checksum.right().value()); return Either.right(checksum.right().value()); } if (!checksum.left().value().equals( oldRresource.getComponentMetadataDefinition().getMetadataDataDefinition().getImportedToscaChecksum())) { log.debug("The checksum of main template yaml of csar with csarUUID {} is not equal to the previous one, existing checksum is {}, new one is {}.", csarUUID, oldRresource.getComponentMetadataDefinition().getMetadataDataDefinition() .getImportedToscaChecksum(), checksum.left().value()); oldRresource.getComponentMetadataDefinition().getMetadataDataDefinition() .setImportedToscaChecksum(checksum.left().value()); } Either lockResult = lockComponent(lockedResourceId, oldRresource, "update Resource From Csar"); if (lockResult.isRight()) { return Either.right(lockResult.right().value()); } String yamlFileName = toscaYamlCsarStatus.left().value().getKey(); String yamlFileContents = toscaYamlCsarStatus.left().value().getValue(); CsarInfo csarInfo = new CsarInfo(newRresource.getName(), user, csarUUID, csar.left().value(), yamlFileContents, true); Map nodeTypesInfo = extractNodeTypesInfo(csarInfo); Either result = null; Either>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle( nodeTypesInfo, csarInfo, oldRresource); if (findNodeTypesArtifactsToHandleRes.isRight()) { log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID()); result = Either.right(findNodeTypesArtifactsToHandleRes.right().value()); return result; } Map>> nodeTypesArtifactsToHandle = findNodeTypesArtifactsToHandleRes .left().value(); try { result = updateResourceFromYaml(oldRresource, newRresource, updateResource, createdArtifacts, yamlFileName, yamlFileContents, csarInfo, nodeTypesInfo, nodeTypesArtifactsToHandle, null, false); } finally { if (result == null || result.isRight()) { log.warn("operation failed. do rollback"); titanDao.rollback(); } else { log.debug("operation success. do commit"); titanDao.commit(); } log.debug("unlock resource {}", lockedResourceId); graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource); } return result; } private Either updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum updateResource, List createdArtifacts, String yamlFileName, String yamlFileContent, CsarInfo csarInfo, Map nodeTypesInfo, Map>> nodeTypesArtifactsToHandle, String nodeName, boolean isNested) { Either result; Either, ResponseFormat> parseNodeTypeInfoYamlEither; boolean inTransaction = true; boolean shouldLock = false; Either, ResponseFormat> prepareForUpdate; Resource preparedResource; Either uploadComponentInstanceInfoMap = parseResourceInfoFromYaml( yamlFileName, newRresource, yamlFileContent, csarInfo.getCreatedNodesToscaResourceNames(), nodeTypesInfo, nodeName); if (uploadComponentInstanceInfoMap.isRight()) { ResponseFormat responseFormat = uploadComponentInstanceInfoMap.right().value(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), newRresource, updateResource); result = Either.right(responseFormat); return result; } Map instances = uploadComponentInstanceInfoMap.left().value() .getInstances(); prepareForUpdate = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock, isNested); if (prepareForUpdate.isRight()) { log.debug("Failed to prepare resource for update : {}", prepareForUpdate.right().value()); result = Either.right(prepareForUpdate.right().value()); return result; } preparedResource = prepareForUpdate.left().value().left; log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent); Either genericResourceEither = handleResourceGenericType(preparedResource); if (genericResourceEither.isRight()) { log.debug("failed to get resource generic type. status is {}", genericResourceEither.right().value()); ResponseFormat responseFormat = genericResourceEither.right().value(); componentsUtils.auditResource(genericResourceEither.right().value(), csarInfo.getModifier(), preparedResource, updateResource); return Either.right(responseFormat); } parseNodeTypeInfoYamlEither = this.handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo, csarInfo, nodeName); if (parseNodeTypeInfoYamlEither.isRight()) { ResponseFormat responseFormat = parseNodeTypeInfoYamlEither.right().value(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), preparedResource, updateResource); result = Either.right(responseFormat); return result; } Map inputs = uploadComponentInstanceInfoMap.left().value().getInputs(); Either createInputsOnResource = createInputsOnResource(preparedResource, csarInfo.getModifier(), inputs, inTransaction); if (createInputsOnResource.isRight()) { log.debug("failed to create resource inputs status is {}", createInputsOnResource.right().value()); ResponseFormat responseFormat = createInputsOnResource.right().value(); componentsUtils.auditResource(createInputsOnResource.right().value(), csarInfo.getModifier(), preparedResource, updateResource); result = Either.right(responseFormat); return result; } preparedResource = createInputsOnResource.left().value(); Either createResourcesInstancesEither = createResourceInstances( csarInfo.getModifier(), yamlFileName, preparedResource, instances, inTransaction, shouldLock, csarInfo.getCreatedNodes()); if (createResourcesInstancesEither.isRight()) { log.debug("failed to create resource instances status is {}", createResourcesInstancesEither.right().value()); ResponseFormat responseFormat = createResourcesInstancesEither.right().value(); componentsUtils.auditResource(createResourcesInstancesEither.right().value(), csarInfo.getModifier(), preparedResource, updateResource); result = Either.right(responseFormat); return result; } preparedResource = createResourcesInstancesEither.left().value(); createResourcesInstancesEither = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances); if (createResourcesInstancesEither.isRight()) { log.debug("failed to create relation between resource instances status is {}", createResourcesInstancesEither.right().value()); result = Either.right(createResourcesInstancesEither.right().value()); return result; } preparedResource = createResourcesInstancesEither.left().value(); Either, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic .validateUpdateVfGroupNames(uploadComponentInstanceInfoMap.left().value().getGroups(), preparedResource.getSystemName()); if (validateUpdateVfGroupNamesRes.isRight()) { return Either.right(validateUpdateVfGroupNamesRes.right().value()); } // add groups to resource Map groups; if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) { groups = validateUpdateVfGroupNamesRes.left().value(); } else { groups = uploadComponentInstanceInfoMap.left().value().getGroups(); } Either updatedGroupsOnResource = updateGroupsOnResource(preparedResource, csarInfo.getModifier(), groups); if (updatedGroupsOnResource.isRight()) { return updatedGroupsOnResource; } preparedResource = updatedGroupsOnResource.left().value(); NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle); Either updateArtifactsEither = createOrUpdateArtifacts(ArtifactOperationEnum.UPDATE, createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); if (updateArtifactsEither.isRight()) { log.debug("failed to update artifacts {}", updateArtifactsEither.right().value()); result = Either.right(updateArtifactsEither.right().value()); return result; } preparedResource = updateArtifactsEither.left().value(); ActionStatus mergingPropsAndInputsStatus = mergeResourceEntities(oldRresource, preparedResource); if (mergingPropsAndInputsStatus != ActionStatus.OK) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource); return Either.right(responseFormat); } Either, ResponseFormat> eitherSetPosition = compositionBusinessLogic .setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId()); result = eitherSetPosition.isRight() ? Either.right(eitherSetPosition.right().value()) : Either.left(preparedResource); return result; } private Either createOrUpdateArtifacts(ArtifactOperationEnum operation, List createdArtifacts, String yamlFileName, CsarInfo csarInfo, Resource preparedResource, NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts, boolean inTransaction, boolean shouldLock) { String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName(); Resource resource = preparedResource; Map>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts .getNodeTypesArtifactsToHandle(); if (preparedResource.getResourceType() == ResourceTypeEnum.CVFC) { if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) { Either, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource, nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true); if (handleNodeTypeArtifactsRes.isRight()) { return Either.right(handleNodeTypeArtifactsRes.right().value()); } } } else { Either createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts, artifactsBusinessLogic.new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction); log.trace("************* Finished to add artifacts from yaml {}", yamlFileName); if (createdCsarArtifactsEither.isRight()) { return createdCsarArtifactsEither; } resource = createdCsarArtifactsEither.left().value(); } return Either.left(resource); } private ActionStatus mergeResourceEntities(Resource oldResource, Resource newResource) { Either mergeResourceBLEither = mergeResourceBLFactory .getInstance(oldResource, newResource); if (mergeResourceBLEither.isRight()) { return mergeResourceBLEither.right().value(); } MergeResourceBusinessLogic mergeResourceBusinessLogic = mergeResourceBLEither.left().value(); return mergeResourceBusinessLogic.mergeResourceEntities(oldResource, newResource); } private Either handleResourceGenericType(Resource resource) { Either genericResourceEither = fetchAndSetDerivedFromGenericType(resource); if (genericResourceEither.isRight()) { return genericResourceEither; } if (resource.shouldGenerateInputs()) { generateAndAddInputsFromGenericTypeProperties(resource, genericResourceEither.left().value()); } return genericResourceEither; } private Either>>, ResponseFormat> findNodeTypesArtifactsToHandle( Map nodeTypesInfo, CsarInfo csarInfo, Resource oldResource) { Map> extractedVfcsArtifacts = CsarUtils .extractVfcsArtifactsFromCsar(csarInfo.getCsar()); Map>> nodeTypesArtifactsToHandle = new HashMap<>(); Either>>, ResponseFormat> nodeTypesArtifactsToHandleRes; try { nodeTypesArtifactsToHandleRes = Either.left(nodeTypesArtifactsToHandle); Map> extractedVfcToscaNames = extractVfcToscaNames(nodeTypesInfo, oldResource.getName(), csarInfo); Either>, ResponseFormat> curNodeTypeArtifactsToHandleRes; EnumMap> curNodeTypeArtifactsToHandle = null; log.debug("Going to fetch node types for resource with name {} during import csar with UUID {}. ", oldResource.getName(), csarInfo.getCsarUUID()); for (Entry> currVfcToscaNameEntry : extractedVfcToscaNames .entrySet()) { String currVfcToscaName = currVfcToscaNameEntry.getValue().getLeft(); String previousVfcToscaName = currVfcToscaNameEntry.getValue().getRight(); String currNamespace = currVfcToscaNameEntry.getKey(); log.debug("Going to fetch node type with tosca name {}. ", currVfcToscaName); Either curVfcRes = toscaOperationFacade .getLatestByToscaResourceName(currVfcToscaName); Resource curNodeType = null; if (curVfcRes.isRight() && curVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) { curVfcRes = toscaOperationFacade.getLatestByToscaResourceName(previousVfcToscaName); } if (curVfcRes.isRight() && curVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) { log.debug("Error occured during fetching node type with tosca name {}, error: {}", currVfcToscaName, curVfcRes.right().value()); ResponseFormat responseFormat = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(curVfcRes.right().value()), csarInfo.getCsarUUID()); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), oldResource, AuditingActionEnum.CREATE_RESOURCE); nodeTypesArtifactsToHandleRes = Either.right(responseFormat); break; } else if (curVfcRes.isLeft()) { curNodeType = curVfcRes.left().value(); } if (!MapUtils.isEmpty(extractedVfcsArtifacts)) { List currArtifacts = new ArrayList<>(); if (extractedVfcsArtifacts.containsKey(currNamespace)) { handleAndAddExtractedVfcsArtifacts(currArtifacts, extractedVfcsArtifacts.get(currNamespace)); } curNodeTypeArtifactsToHandleRes = findNodeTypeArtifactsToHandle(curNodeType, currArtifacts); if (curNodeTypeArtifactsToHandleRes.isRight()) { nodeTypesArtifactsToHandleRes = Either.right(curNodeTypeArtifactsToHandleRes.right().value()); break; } curNodeTypeArtifactsToHandle = curNodeTypeArtifactsToHandleRes.left().value(); } else if (curNodeType != null) { // delete all artifacts if have not received artifacts from // csar curNodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class); List artifactsToDelete = new ArrayList<>(); // delete all informational artifacts artifactsToDelete.addAll(curNodeType.getArtifacts().values().stream() .filter(a -> a.getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL) .collect(Collectors.toList())); // delete all deployment artifacts artifactsToDelete.addAll(curNodeType.getDeploymentArtifacts().values()); if (!artifactsToDelete.isEmpty()) { curNodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete); } } if (MapUtils.isNotEmpty(curNodeTypeArtifactsToHandle)) { nodeTypesArtifactsToHandle.put(currVfcToscaNameEntry.getKey(), curNodeTypeArtifactsToHandle); } } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); nodeTypesArtifactsToHandleRes = Either.right(responseFormat); log.debug("Exception occured when findNodeTypesUpdatedArtifacts, error is:{}", e.getMessage(), e); } return nodeTypesArtifactsToHandleRes; } private Either>, ResponseFormat> findNodeTypeArtifactsToHandle( Resource curNodeType, List extractedArtifacts) { Either>, ResponseFormat> nodeTypeArtifactsToHandleRes = null; EnumMap> nodeTypeArtifactsToHandle = null; Wrapper responseWrapper = new Wrapper<>(); try { List artifactsToUpload = new ArrayList<>(extractedArtifacts); List artifactsToUpdate = new ArrayList<>(); List artifactsToDelete = new ArrayList<>(); if (curNodeType != null) { Map existingArtifacts = new HashMap<>(); if (curNodeType.getDeploymentArtifacts() != null) { existingArtifacts.putAll(curNodeType.getDeploymentArtifacts()); } if (curNodeType.getArtifacts() != null) { existingArtifacts .putAll(curNodeType.getArtifacts().entrySet().stream() .filter(e -> e.getValue() .getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL) .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))); } for (ArtifactDefinition currNewArtifact : extractedArtifacts) { ArtifactDefinition foundArtifact; if (!existingArtifacts.isEmpty()) { foundArtifact = existingArtifacts.values().stream() .filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName())).findFirst() .orElse(null); if (foundArtifact != null) { if (foundArtifact.getArtifactType().equals(currNewArtifact.getArtifactType())) { if (!foundArtifact.getArtifactChecksum() .equals(currNewArtifact.getArtifactChecksum())) { foundArtifact.setPayload(currNewArtifact.getPayloadData()); foundArtifact.setPayloadData( Base64.encodeBase64String(currNewArtifact.getPayloadData())); foundArtifact.setArtifactChecksum(GeneralUtility .calculateMD5Base64EncodedByByteArray(currNewArtifact.getPayloadData())); artifactsToUpdate.add(foundArtifact); } existingArtifacts.remove(foundArtifact.getArtifactLabel()); artifactsToUpload.remove(currNewArtifact); } else { log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName()); ResponseFormat responseFormat = ResponseFormatManager.getInstance().getResponseFormat( ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(), foundArtifact.getArtifactType()); responseWrapper.setInnerElement(responseFormat); break; } } } } if (responseWrapper.isEmpty()) { artifactsToDelete.addAll(existingArtifacts.values()); } } if (responseWrapper.isEmpty()) { if (!artifactsToUpload.isEmpty() || !artifactsToUpdate.isEmpty() || !artifactsToDelete.isEmpty()) { nodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class); if (!artifactsToUpload.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload); if (!artifactsToUpdate.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate); if (!artifactsToDelete.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete); } nodeTypeArtifactsToHandleRes = Either.left(nodeTypeArtifactsToHandle); } if (!responseWrapper.isEmpty()) { nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement()); } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); responseWrapper.setInnerElement(responseFormat); log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e); } return nodeTypeArtifactsToHandleRes; } /** * Changes resource life cycle state to checked out * * @param resource * @param user * @param inTransaction * @return */ private Either checkoutResource(Resource resource, User user, boolean inTransaction) { Either checkoutResourceRes; try { if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState() .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { log.debug( "************* Going to change life cycle state of resource {} to not certified checked out. ", resource.getName()); Either checkoutRes = lifecycleBusinessLogic.changeComponentState( resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT, new LifecycleChangeInfoWithAction("certification on import", LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true); if (checkoutRes.isRight()) { log.debug("Could not change state of component {} with uid {} to checked out. Status is {}. ", resource.getComponentType().getNodeType(), resource.getUniqueId(), checkoutRes.right().value().getStatus()); checkoutResourceRes = Either.right(checkoutRes.right().value()); } else { checkoutResourceRes = Either.left((Resource) checkoutRes.left().value()); } } else { checkoutResourceRes = Either.left(resource); } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); checkoutResourceRes = Either.right(responseFormat); log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e); } return checkoutResourceRes; } /** * Handles Artifacts of NodeType * * @param nodeTypeResource * @param nodeTypeArtifactsToHandle * @param user * @param inTransaction * @return */ public Either, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource, Map> nodeTypeArtifactsToHandle, List createdArtifacts, User user, boolean inTransaction, boolean ignoreLifecycleState) { Either, ResponseFormat> handleNodeTypeArtifactsRequestRes; Either, ResponseFormat> handleNodeTypeArtifactsRes = null; Either changeStateResponse; try { changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction); if (changeStateResponse.isRight()) { return Either.right(changeStateResponse.right().value()); } nodeTypeResource = changeStateResponse.left().value(); List handledNodeTypeArtifacts = new ArrayList<>(); log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName()); for (Entry> curOperationEntry : nodeTypeArtifactsToHandle .entrySet()) { ArtifactOperationEnum curOperation = curOperationEntry.getKey(); List curArtifactsToHandle = curOperationEntry.getValue(); if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) { log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName()); handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts, artifactsBusinessLogic.new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction); if (handleNodeTypeArtifactsRequestRes.isRight()) { handleNodeTypeArtifactsRes = Either.right(handleNodeTypeArtifactsRequestRes.right().value()); break; } if (ArtifactOperationEnum.isCreateOrLink(curOperation)) { createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes.left().value()); } handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes.left().value()); } } if (handleNodeTypeArtifactsRes == null) { handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts); } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); handleNodeTypeArtifactsRes = Either.right(responseFormat); log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e); } return handleNodeTypeArtifactsRes; } private Map> extractVfcToscaNames(Map nodeTypesInfo, String vfResourceName, CsarInfo csarInfo) { Map> vfcToscaNames = new HashMap<>(); Map nodes = extractAllNodes(nodeTypesInfo, csarInfo); if (!nodes.isEmpty()) { Iterator> nodesNameEntry = nodes.entrySet().iterator(); while (nodesNameEntry.hasNext()) { Entry nodeType = nodesNameEntry.next(); ImmutablePair toscaResourceName = buildNestedToscaResourceName( ResourceTypeEnum.VFC.name(), vfResourceName, nodeType.getKey()); vfcToscaNames.put(nodeType.getKey(), toscaResourceName); } } for (NodeTypeInfo cvfc : nodeTypesInfo.values()) { vfcToscaNames.put(cvfc.getType(), buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(), vfResourceName, cvfc.getType())); } return vfcToscaNames; } private Map extractAllNodes(Map nodeTypesInfo, CsarInfo csarInfo) { Map nodes = new HashMap<>(); for (NodeTypeInfo nodeTypeInfo : nodeTypesInfo.values()) { extractNodeTypes(nodes, nodeTypeInfo.getMappedToscaTemplate()); } extractNodeTypes(nodes, csarInfo.getMappedToscaMainTemplate()); return nodes; } private void extractNodeTypes(Map nodes, Map mappedToscaTemplate) { Either, ResultStatusEnum> eitherNodeTypes = ImportUtils .findFirstToscaMapElement(mappedToscaTemplate, ToscaTagNamesEnum.NODE_TYPES); if (eitherNodeTypes.isLeft()) { nodes.putAll(eitherNodeTypes.left().value()); } } public Either createResourceFromCsar(Resource resource, User user, Either, StorageOperationStatus> csarUIPayload, String csarUUID) { log.trace("************* created successfully from YAML, resource TOSCA "); Either, StorageOperationStatus> csar = null; if (csarUIPayload != null && csarUIPayload.left() != null && csarUIPayload.left().value() != null) { csar = csarUIPayload; } else { csar = csarOperation.getCsar(csarUUID, user); } Either, ResponseFormat> toscaYamlCsarStatus = validateAndParseCsar(resource, user, csarUUID, csar); if (toscaYamlCsarStatus.isRight()) { return Either.right(toscaYamlCsarStatus.right().value()); } Either toscaYamlChecksum = CsarValidationUtils.getToscaYamlChecksum(csar.left().value(), csarUUID, componentsUtils); if (toscaYamlChecksum.isRight()) { log.debug("Failed to calculate checksum for CSAR {}, error {}", csarUUID, toscaYamlChecksum.right().value()); return Either.right(toscaYamlChecksum.right().value()); } resource.getComponentMetadataDefinition().getMetadataDataDefinition() .setImportedToscaChecksum(toscaYamlChecksum.left().value()); String yamlFileName = toscaYamlCsarStatus.left().value().getKey(); String yamlFileContents = toscaYamlCsarStatus.left().value().getValue(); log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContents); CsarInfo csarInfo = new CsarInfo(resource.getName(), user, csarUUID, csar.left().value(), yamlFileContents, false); Map nodeTypesInfo = extractNodeTypesInfo(csarInfo); Either>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle( nodeTypesInfo, csarInfo, resource); if (findNodeTypesArtifactsToHandleRes.isRight()) { log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID()); return Either.right(findNodeTypesArtifactsToHandleRes.right().value()); } Either createResourceFromYaml = createResourceFromYaml(resource, yamlFileContents, yamlFileName, nodeTypesInfo, csarInfo, findNodeTypesArtifactsToHandleRes.left().value(), true, false, null); if (createResourceFromYaml.isRight()) { log.debug("Couldn't create resource from YAML"); return Either.right(createResourceFromYaml.right().value()); } Resource vfResource = createResourceFromYaml.left().value(); log.trace("*************VF Resource created successfully from YAML, resource TOSCA name: {}", vfResource.getToscaResourceName()); return Either.left(vfResource); } private Map extractNodeTypesInfo(CsarInfo csarInfo) { Map nodeTypesInfo = new HashMap<>(); List> globalSubstitutes = new ArrayList<>(); for (Map.Entry entry : csarInfo.getCsar().entrySet()) { extractNodeTypeInfo(nodeTypesInfo, globalSubstitutes, entry); } if (CollectionUtils.isNotEmpty(globalSubstitutes)) { setDerivedFrom(nodeTypesInfo, globalSubstitutes); } markNestedVfc(csarInfo.getMappedToscaMainTemplate(), nodeTypesInfo); return nodeTypesInfo; } @SuppressWarnings("unchecked") private void setDerivedFrom(Map nodeTypesInfo, List> globalSubstitutes) { for (Map.Entry entry : globalSubstitutes) { String yamlFileContents = new String(entry.getValue()); Map mappedToscaTemplate = (Map) new Yaml().load(yamlFileContents); Either nodeTypesEither = ImportUtils.findToscaElement(mappedToscaTemplate, ToscaTagNamesEnum.NODE_TYPES, ToscaElementTypeEnum.MAP); if (nodeTypesEither.isLeft()) { Map nodeTypes = (Map) nodeTypesEither.left().value(); for (Entry nodeType : nodeTypes.entrySet()) { Map nodeTypeMap = (Map) nodeType.getValue(); if (nodeTypeMap.containsKey(ToscaTagNamesEnum.DERIVED_FROM.getElementName())) { if (nodeTypesInfo.containsKey(nodeType.getKey())) { NodeTypeInfo nodeTypeInfo = nodeTypesInfo.get(nodeType.getKey()); List derivedFrom = new ArrayList<>(); derivedFrom.add((String) nodeTypeMap.get(ToscaTagNamesEnum.DERIVED_FROM.getElementName())); nodeTypeInfo.setDerivedFrom(derivedFrom); } } } } } } @SuppressWarnings("unchecked") private void extractNodeTypeInfo(Map nodeTypesInfo, List> globalSubstitutes, Map.Entry entry) { if (Pattern.compile(CsarUtils.SERVICE_TEMPLATE_PATH_PATTERN).matcher(entry.getKey()).matches()) { if (!isGlobalSubstitute(entry.getKey())) { String yamlFileContents = new String(entry.getValue()); Map mappedToscaTemplate = (Map) new Yaml().load(yamlFileContents); Either substitutionMappingsEither = ImportUtils.findToscaElement( mappedToscaTemplate, ToscaTagNamesEnum.SUBSTITUTION_MAPPINGS, ToscaElementTypeEnum.MAP); if (substitutionMappingsEither.isLeft()) { Map substitutionMappings = (Map) substitutionMappingsEither.left() .value(); if (substitutionMappings.containsKey(ToscaTagNamesEnum.NODE_TYPE.getElementName())) { NodeTypeInfo nodeTypeInfo = new NodeTypeInfo(); nodeTypeInfo.setType( (String) substitutionMappings.get(ToscaTagNamesEnum.NODE_TYPE.getElementName())); nodeTypeInfo.setTemplateFileName(entry.getKey()); nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate); nodeTypesInfo.put(nodeTypeInfo.getType(), nodeTypeInfo); } } } else { globalSubstitutes.add(entry); } } } @SuppressWarnings("unchecked") private void markNestedVfc(Map mappedToscaTemplate, Map nodeTypesInfo) { Either nodeTemplatesEither = ImportUtils.findToscaElement(mappedToscaTemplate, ToscaTagNamesEnum.NODE_TEMPLATES, ToscaElementTypeEnum.MAP); if (nodeTemplatesEither.isLeft()) { Map nodeTemplates = (Map) nodeTemplatesEither.left().value(); for (Entry nodeTemplateEntry : nodeTemplates.entrySet()) { Map nodeTemplate = (Map) nodeTemplateEntry.getValue(); if (nodeTemplate.containsKey(ToscaTagNamesEnum.TYPE.getElementName())) { String type = (String) nodeTemplate.get(ToscaTagNamesEnum.TYPE.getElementName()); if (nodeTypesInfo.containsKey(type)) { NodeTypeInfo nodeTypeInfo = nodeTypesInfo.get(type); nodeTypeInfo.setNested(true); } } } } } private boolean isGlobalSubstitute(String fileName) { return fileName.equalsIgnoreCase(Constants.GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE) || fileName.equalsIgnoreCase(Constants.ABSTRACT_SUBSTITUTE_GLOBAL_TYPES_SERVICE_TEMPLATE); } private Either, ResponseFormat> validateAndParseCsar(Resource resource, User user, String csarUUID, Either, StorageOperationStatus> csar) { if (csar.isRight()) { StorageOperationStatus value = csar.right().value(); log.debug("Error when fetching csar with ID {}, error: {}", csarUUID, value); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Creating resource from CSAR: fetching CSAR with id " + csarUUID + " failed"); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(value), csarUUID); componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.CREATE_RESOURCE); return Either.right(responseFormat); } Either validateCsarStatus = CsarValidationUtils.validateCsar(csar.left().value(), csarUUID, componentsUtils); if (validateCsarStatus.isRight()) { ResponseFormat responseFormat = validateCsarStatus.right().value(); log.debug("Error when validate csar with ID {}, error: {}", csarUUID, responseFormat); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Creating resource from CSAR: fetching CSAR with id " + csarUUID + " failed"); componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.CREATE_RESOURCE); return Either.right(responseFormat); } Either, ResponseFormat> toscaYamlCsarStatus = CsarValidationUtils .getToscaYaml(csar.left().value(), csarUUID, componentsUtils); if (toscaYamlCsarStatus.isRight()) { ResponseFormat responseFormat = toscaYamlCsarStatus.right().value(); log.debug("Error when try to get csar toscayamlFile with csar ID {}, error: {}", csarUUID, responseFormat); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Creating resource from CSAR: fetching CSAR with id " + csarUUID + " failed"); componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.CREATE_RESOURCE); return Either.right(responseFormat); } return toscaYamlCsarStatus; } private Either validateResourceBeforeCreate(Resource resource, User user, boolean inTransaction) { log.trace("validating resource before create"); Either eitherCreator = validateUser(user, "Create Resource", resource, AuditingActionEnum.CREATE_RESOURCE, false); if (eitherCreator.isRight()) { return Either.right(eitherCreator.right().value()); } user.copyData(eitherCreator.left().value()); // validate user role Either validateRes = validateUserRole(user, resource, new ArrayList(), AuditingActionEnum.CREATE_RESOURCE, null); if (validateRes.isRight()) { return Either.right(validateRes.right().value()); } // VF / PNF "derivedFrom" should be null (or ignored) if (ModelConverter.isAtomicComponent(resource)) { Either validateDerivedFromNotEmpty = validateDerivedFromNotEmpty(user, resource, AuditingActionEnum.CREATE_RESOURCE); if (validateDerivedFromNotEmpty.isRight()) { return Either.right(validateDerivedFromNotEmpty.right().value()); } } return validateResourceBeforeCreate(resource, user, AuditingActionEnum.CREATE_RESOURCE, inTransaction, null); } // resource, yamlFileContents, yamlFileName, nodeTypesInfo,csarInfo, // nodeTypesArtifactsToCreate, true, false, null private Either createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName, Map nodeTypesInfo, CsarInfo csarInfo, Map>> nodeTypesArtifactsToCreate, boolean shouldLock, boolean inTransaction, String nodeName) { List createdArtifacts = new ArrayList(); log.trace("************* createResourceFromYaml before parse yaml "); Either parseResourceInfoFromYamlEither = parseResourceInfoFromYaml( yamlName, resource, topologyTemplateYaml, csarInfo.getCreatedNodesToscaResourceNames(), nodeTypesInfo, nodeName); if (parseResourceInfoFromYamlEither.isRight()) { ResponseFormat responseFormat = parseResourceInfoFromYamlEither.right().value(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return Either.right(responseFormat); } log.trace("************* createResourceFromYaml after parse yaml "); ParsedToscaYamlInfo parsedToscaYamlInfo = parseResourceInfoFromYamlEither.left().value(); log.debug("The parsed tosca yaml info is {}", parsedToscaYamlInfo); log.trace("************* createResourceFromYaml before create "); Either createdResourceResponse = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName); log.trace("************* createResourceFromYaml after create "); if (createdResourceResponse.isRight()) { ResponseFormat responseFormat = createdResourceResponse.right().value(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return Either.right(responseFormat); } return createdResourceResponse; } public Either, ResponseFormat> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map mappedToscaTemplate, boolean needLock, Map>> nodeTypesArtifactsToHandle, List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo) { Either tosca_version = ImportUtils.findFirstToscaStringElement(mappedToscaTemplate, ToscaTagNamesEnum.TOSCA_VERSION); if (tosca_version.isRight()) { ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_TOSCA_TEMPLATE); return Either.right(responseFormat); } Either, ResultStatusEnum> eitherNodeTypes = ImportUtils .findFirstToscaMapElement(mappedToscaTemplate, ToscaTagNamesEnum.NODE_TYPES); Either, ResponseFormat> result = Either.left(csarInfo.getCreatedNodes()); Map mapToConvert = new HashMap(); mapToConvert.put(ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), tosca_version.left().value()); Resource vfcCreated = null; if (eitherNodeTypes.isLeft()) { Iterator> nodesNameValue = eitherNodeTypes.left().value().entrySet().iterator(); while (nodesNameValue.hasNext()) { Entry nodeType = nodesNameValue.next(); Map> nodeTypeArtifactsToHandle = nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey()); if (nodeTypesInfo.containsKey(nodeType.getKey())) { log.trace("************* Going to handle nested vfc {}", nodeType.getKey()); Either handleNeatedVfcYaml = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeType.getKey()); log.trace("************* Finished to handle nested vfc {}", nodeType.getKey()); if (handleNeatedVfcYaml.isRight()) { return Either.right(handleNeatedVfcYaml.right().value()); } vfcCreated = handleNeatedVfcYaml.left().value(); } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames().containsKey(nodeType.getKey())) { log.trace("************* Going to create node {}", nodeType.getKey()); Either, ResponseFormat> resourceCreated = this .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true); log.debug("************* Finished to create node {}", nodeType.getKey()); if (resourceCreated.isRight()) { return Either.right(resourceCreated.right().value()); } vfcCreated = resourceCreated.left().value().getLeft(); csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName()); } if (vfcCreated != null) { csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated); } mapToConvert.remove(ToscaTagNamesEnum.NODE_TYPES.getElementName()); } } return result; } private Either handleNestedVfc(Resource resource, Map>> nodesArtifactsToHandle, List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName) { Either handleNestedVfcRes = Either.left(resource); String yamlName = nodesInfo.get(nodeName).getTemplateFileName(); Map nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate(); log.debug("************* Going to create node types from yaml {}", yamlName); Either, ResponseFormat> createNodeTypesRes = createResourcesFromYamlNodeTypesList( yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo); if (createNodeTypesRes.isRight()) { log.debug("Failed to create node types from yaml {}. Status is {}", yamlName, createNodeTypesRes.right().value()); return Either.right(createNodeTypesRes.right().value()); } log.debug("************* Finished to create node types from yaml {}", yamlName); if (nestedVfcJsonMap.containsKey(ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) { log.debug("************* Going to handle complex VFC from yaml {}", yamlName); handleNestedVfcRes = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName); } return handleNestedVfcRes; } private Either handleComplexVfc(Resource resource, Map>> nodesArtifactsToHandle, List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) { Either result = null; Resource oldComplexVfc = null; Resource newComplexVfc = null; Either buildCvfcRes = buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo); if (buildCvfcRes.isRight()) { log.debug("Failed to validate complex VFC for node {}. ", nodeName); result = buildCvfcRes; } if (result == null) { newComplexVfc = buildCvfcRes.left().value(); Either oldComplexVfcRes = toscaOperationFacade .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName()); if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) { oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName( buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName).getRight()); } if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) { log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(), oldComplexVfcRes.right().value()); result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } else if (oldComplexVfcRes.isLeft()) { log.debug("validate derived before update"); Either eitherValidation = validateNestedDerivedFromDuringUpdate( oldComplexVfcRes.left().value(), newComplexVfc, ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion())); if (eitherValidation.isLeft()) { oldComplexVfc = oldComplexVfcRes.left().value(); } } } if (result == null) { result = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc); } if (result.isLeft()) { newComplexVfc = result.left().value(); csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName()); LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction( "certification on import", LifecycleChanceActionEnum.CREATE_FROM_CSAR); log.debug("Going to certify cvfc {}. ", newComplexVfc.getName()); result = propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true); if (result.isRight()) { log.debug("Failed to certify complex VFC resource {}. ", newComplexVfc.getName()); } } if (result.isLeft()) { csarInfo.getCreatedNodes().put(nodeName, result.left().value()); csarInfo.getCvfcToCreateQueue().remove(); } return result; } private Either handleComplexVfc( Map>> nodesArtifactsToHandle, List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName, Resource oldComplexVfc, Resource newComplexVfc) { Either handleComplexVfcRes; Map mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate(); String yamlContent = new String(csarInfo.getCsar().get(yamlName)); Map newNodeTypesInfo = nodesInfo.entrySet().stream() .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue().getUnmarkedCopy())); markNestedVfc(mappedToscaTemplate, newNodeTypesInfo); if (oldComplexVfc == null) { handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle, false, true, nodeName); if (handleComplexVfcRes.isRight()) { log.debug("Failed to create resource {} from YAML {}. ", newComplexVfc.getName(), yamlName); } } else { handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA, createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true); if (handleComplexVfcRes.isRight()) { log.debug("Failed to update resource {} from YAML {}. ", oldComplexVfc.getName(), yamlName); } } return handleComplexVfcRes; } private Either buildValidComplexVfc(Resource resource, CsarInfo csarInfo, String nodeName, Map nodesInfo) { Either result = null; Resource complexVfc = buildComplexVfcMetadata(resource, csarInfo, nodeName, nodesInfo); log.debug("************* Going to validate complex VFC from yaml {}", complexVfc.getName()); if (!csarInfo.getCvfcToCreateQueue().contains(nodeName)) { csarInfo.getCvfcToCreateQueue().add(nodeName); } else { log.debug("Failed to validate complex VFC {}. Loop detected, VSP {}. ", complexVfc.getName(), csarInfo.getVfResourceName()); result = Either.right(componentsUtils.getResponseFormat(ActionStatus.CFVC_LOOP_DETECTED, csarInfo.getVfResourceName(), complexVfc.getName())); } if (result == null) { result = validateResourceBeforeCreate(complexVfc, csarInfo.getModifier(), AuditingActionEnum.IMPORT_RESOURCE, true, csarInfo); if (result.isRight()) { log.debug("Failed to validate complex VFC {}. ", complexVfc.getName()); } } return result; } private String getNodeTypeActualName(String fullName) { String nameWithouNamespacePrefix = fullName .substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length()); String[] findTypes = nameWithouNamespacePrefix.split("\\."); String resourceType = findTypes[0]; return nameWithouNamespacePrefix.substring(resourceType.length()); } private Either, ResponseFormat> createNodeTypeResourceFromYaml( String yamlName, Entry nodeNameValue, User user, Map mapToConvert, Resource resourceVf, boolean needLock, Map> nodeTypeArtifactsToHandle, List nodeTypesNewCreatedArtifacts, boolean forceCertificationAllowed, CsarInfo csarInfo, boolean isNested) { Either resourceMetaData = fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), user); if (resourceMetaData.isRight()) { return Either.right(resourceMetaData.right().value()); } String singleVfcYaml = buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.left().value().getResourceType(), csarInfo); Either eitherCreator = validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true); if (eitherCreator.isRight()) { return Either.right(eitherCreator.right().value()); } user = eitherCreator.left().value(); return this.createResourceFromNodeType(singleVfcYaml, resourceMetaData.left().value(), user, true, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested); } private String buildNodeTypeYaml(Entry nodeNameValue, Map mapToConvert, String nodeResourceType, CsarInfo csarInfo) { // We need to create a Yaml from each node_types in order to create // resource from each node type using import normative flow. DumperOptions options = new DumperOptions(); options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); Yaml yaml = new Yaml(options); Map node = new HashMap<>(); node.put(buildNestedToscaResourceName(nodeResourceType, csarInfo.getVfResourceName(), nodeNameValue.getKey()) .getLeft(), nodeNameValue.getValue()); mapToConvert.put(ToscaTagNamesEnum.NODE_TYPES.getElementName(), node); return yaml.dumpAsMap(mapToConvert); } public Either validateResourceCreationFromNodeType(Resource resource, User creator) { Either validateDerivedFromNotEmpty = this.validateDerivedFromNotEmpty(creator, resource, AuditingActionEnum.CREATE_RESOURCE); if (validateDerivedFromNotEmpty.isRight()) { return Either.right(validateDerivedFromNotEmpty.right().value()); } return Either.left(true); } public Either, ResponseFormat> createResourceFromNodeType(String nodeTypeYaml, UploadResourceInfo resourceMetaData, User creator, boolean isInTransaction, boolean needLock, Map> nodeTypeArtifactsToHandle, List nodeTypesNewCreatedArtifacts, boolean forceCertificationAllowed, CsarInfo csarInfo, String nodeName, boolean isNested) { LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction("certification on import", LifecycleChanceActionEnum.CREATE_FROM_CSAR); Function> validator = (resource) -> this .validateResourceCreationFromNodeType(resource, creator); return this.resourceImportManager.importCertifiedResource(nodeTypeYaml, resourceMetaData, creator, validator, lifecycleChangeInfo, isInTransaction, true, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeName, isNested); } private Either fillResourceMetadata(String yamlName, Resource resourceVf, String nodeName, User user) { UploadResourceInfo resourceMetaData = new UploadResourceInfo(); // validate nodetype name prefix if (!nodeName.startsWith(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX)) { log.debug("invalid nodeName:{} does not start with {}.", nodeName, Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX); ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, resourceMetaData.getName(), nodeName); return Either.right(responseFormat); } String actualName = this.getNodeTypeActualName(nodeName); String namePrefix = nodeName.replace(actualName, ""); String resourceType = namePrefix.substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length()); // if we import from csar, the node_type name can be // org.openecomp.resource.abstract.node_name - in this case we always // create a vfc if (resourceType.equals(Constants.ABSTRACT)) { resourceType = ResourceTypeEnum.VFC.name().toLowerCase(); } // validating type if (!ResourceTypeEnum.containsName(resourceType.toUpperCase())) { log.debug("invalid resourceType:{} the type is not one of the valide types:{}.", resourceType.toUpperCase(), ResourceTypeEnum.values()); ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, resourceMetaData.getName(), nodeName); return Either.right(responseFormat); } // Setting name resourceMetaData.setName(resourceVf.getSystemName() + actualName); // Setting type from name String type = resourceType.toUpperCase(); resourceMetaData.setResourceType(type); resourceMetaData.setDescription(ImportUtils.Constants.INNER_VFC_DESCRIPTION); resourceMetaData.setIcon(ImportUtils.Constants.DEFAULT_ICON); resourceMetaData.setContactId(user.getUserId()); resourceMetaData.setVendorName(resourceVf.getVendorName()); resourceMetaData.setVendorRelease(resourceVf.getVendorRelease()); // Setting tag List tags = new ArrayList<>(); tags.add(resourceMetaData.getName()); resourceMetaData.setTags(tags); // Setting category CategoryDefinition category = new CategoryDefinition(); category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME); SubCategoryDefinition subCategory = new SubCategoryDefinition(); subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY); category.addSubCategory(subCategory); List categories = new ArrayList<>(); categories.add(category); resourceMetaData.setCategories(categories); return Either.left(resourceMetaData); } private Resource buildComplexVfcMetadata(Resource resourceVf, CsarInfo csarInfo, String nodeName, Map nodesInfo) { Resource cvfc = new Resource(); NodeTypeInfo nodeTypeInfo = nodesInfo.get(nodeName); cvfc.setName(buildCvfcName(csarInfo.getVfResourceName(), nodeName)); cvfc.setNormalizedName(ValidationUtils.normaliseComponentName(cvfc.getName())); cvfc.setSystemName(ValidationUtils.convertToSystemName(cvfc.getName())); cvfc.setResourceType(ResourceTypeEnum.CVFC); cvfc.setAbstract(true); cvfc.setDerivedFrom(nodeTypeInfo.getDerivedFrom()); cvfc.setDescription(ImportUtils.Constants.CVFC_DESCRIPTION); cvfc.setIcon(ImportUtils.Constants.DEFAULT_ICON); cvfc.setContactId(csarInfo.getModifier().getUserId()); cvfc.setCreatorUserId(csarInfo.getModifier().getUserId()); cvfc.setVendorName(resourceVf.getVendorName()); cvfc.setVendorRelease(resourceVf.getVendorRelease()); cvfc.setResourceVendorModelNumber(resourceVf.getResourceVendorModelNumber()); cvfc.setToscaResourceName( buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName) .getLeft()); cvfc.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID()); List tags = new ArrayList<>(); tags.add(cvfc.getName()); cvfc.setTags(tags); CategoryDefinition category = new CategoryDefinition(); category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME); SubCategoryDefinition subCategory = new SubCategoryDefinition(); subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY); category.addSubCategory(subCategory); List categories = new ArrayList<>(); categories.add(category); cvfc.setCategories(categories); cvfc.setVersion(ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION); cvfc.setLifecycleState(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE_NOT_CERTIFIED_CHECKOUT); cvfc.setHighestVersion(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION); return cvfc; } private String buildCvfcName(String resourceVfName, String nodeName) { String nameWithouNamespacePrefix = nodeName .substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length()); String[] findTypes = nameWithouNamespacePrefix.split("\\."); String resourceType = findTypes[0]; String resourceName = resourceVfName + "-" + nameWithouNamespacePrefix.substring(resourceType.length() + 1); return addCvfcSuffixToResourceName(resourceName); } private Either createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo, AuditingActionEnum actionEnum, boolean isNormative, List createdArtifacts, String topologyTemplateYaml, Map nodeTypesInfo, CsarInfo csarInfo, Map>> nodeTypesArtifactsToCreate, boolean shouldLock, boolean inTransaction, String nodeName) { boolean result = true; List nodeTypesNewCreatedArtifacts = new ArrayList<>(); if (shouldLock) { Either lockResult = lockComponentByName(resource.getSystemName(), resource, "Create Resource"); if (lockResult.isRight()) { ResponseFormat responseFormat = lockResult.right().value(); return Either.right(responseFormat); } log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult); } try { log.trace("************* createResourceFromYaml before full create resource {}", yamlName); Either genericResourceEither = fetchAndSetDerivedFromGenericType(resource); if (genericResourceEither.isRight()) { result = false; return genericResourceEither; } Either createResourcesEither = createResourceTransaction(resource, csarInfo.getModifier(), isNormative, inTransaction); log.trace("************* createResourceFromYaml after full create resource {}", yamlName); if (createResourcesEither.isRight()) { result = false; return createResourcesEither; } resource = createResourcesEither.left().value(); // add groups to resource log.trace("************* Going to add inputs from yaml {}", yamlName); if (resource.shouldGenerateInputs()) generateAndAddInputsFromGenericTypeProperties(resource, genericResourceEither.left().value()); Map inputs = parsedToscaYamlInfo.getInputs(); Either createInputsOnResource = createInputsOnResource(resource, csarInfo.getModifier(), inputs, inTransaction); if (createInputsOnResource.isRight()) { result = false; return createInputsOnResource; } resource = createInputsOnResource.left().value(); log.trace("************* Finish to add inputs from yaml {}", yamlName); Map uploadComponentInstanceInfoMap = parsedToscaYamlInfo .getInstances(); log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName); createResourcesEither = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, actionEnum, topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName); log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName); if (createResourcesEither.isRight()) { result = false; return createResourcesEither; } resource = createResourcesEither.left().value(); // validate update vf module group names Either, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), resource.getSystemName()); if (validateUpdateVfGroupNamesRes.isRight()) { result = false; return Either.right(validateUpdateVfGroupNamesRes.right().value()); } // add groups to resource Map groups; log.trace("************* Going to add groups from yaml {}", yamlName); if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) { groups = validateUpdateVfGroupNamesRes.left().value(); } else { groups = parsedToscaYamlInfo.getGroups(); } Either createGroupsOnResource = createGroupsOnResource(resource, csarInfo.getModifier(), groups); if (createGroupsOnResource.isRight()) { result = false; return createGroupsOnResource; } resource = createGroupsOnResource.left().value(); log.trace("************* Finished to add groups from yaml {}", yamlName); log.trace("************* Going to add artifacts from yaml {}", yamlName); NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate); Either createArtifactsEither = createOrUpdateArtifacts(ArtifactOperationEnum.CREATE, createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); if (createArtifactsEither.isRight()) { log.debug("failed to update artifacts {}", createArtifactsEither.right().value()); return createArtifactsEither; } resource = createArtifactsEither.left().value(); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum); ASDCKpiApi.countCreatedResourcesKPI(); return Either.left(resource); } finally { if (!inTransaction) { if (!result) { log.warn("operation failed. do rollback"); titanDao.rollback(); if (!createdArtifacts.isEmpty() || !nodeTypesNewCreatedArtifacts.isEmpty()) { createdArtifacts.addAll(nodeTypesNewCreatedArtifacts); log.debug("component and all its artifacts were deleted, id = {}", resource.getName()); } } else { log.debug("operation success. do commit"); titanDao.commit(); } } if (shouldLock) { graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource); } } } private Either createGroupsOnResource(Resource resource, User user, Map groups) { if (groups != null && !groups.isEmpty()) { Either, ResponseFormat> mergeGroupsUsingResource = updateGroupMembersUsingResource( groups, resource); if (mergeGroupsUsingResource.isRight()) { log.debug("Failed to prepare groups for creation"); return Either.right(mergeGroupsUsingResource.right().value()); } List groupsAsList = mergeGroupsUsingResource.left().value(); Either, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList); if (createGroups.isRight()) { return Either.right(createGroups.right().value()); } } else { return Either.left(resource); } Either updatedResource = toscaOperationFacade .getToscaElement(resource.getUniqueId()); if (updatedResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource); return Either.right(responseFormat); } return Either.left(updatedResource.left().value()); } private Either updateGroupsOnResource(Resource resource, User user, Map groups) { if (groups != null && false == groups.isEmpty()) { List groupsFromResource = resource.getGroups(); Either, ResponseFormat> mergeGroupsUsingResource = updateGroupMembersUsingResource( groups, resource); if (mergeGroupsUsingResource.isRight()) { log.debug("Failed to prepare groups for creation"); return Either.right(mergeGroupsUsingResource.right().value()); } List groupsAsList = mergeGroupsUsingResource.left().value(); List groupsToUpdate = new ArrayList(); List groupsToDelete = new ArrayList(); List groupsToCreate = new ArrayList(); if (groupsFromResource != null && !groupsFromResource.isEmpty()) { for (GroupDefinition group : groupsAsList) { Optional op = groupsFromResource.stream() .filter(p -> p.getName().equalsIgnoreCase(group.getName())).findAny(); if (op.isPresent()) { GroupDefinition groupToUpdate = op.get(); groupToUpdate.setMembers(group.getMembers()); groupsToUpdate.add(groupToUpdate); } else { groupsToCreate.add(group); } } for (GroupDefinition group : groupsFromResource) { Optional op = groupsAsList.stream() .filter(p -> p.getName().equalsIgnoreCase(group.getName())).findAny(); if (!op.isPresent() && (group.getArtifacts() == null || group.getArtifacts().isEmpty())) { groupsToDelete.add(group); } } } else groupsToCreate.addAll(groupsAsList); Either, ResponseFormat> prepareGroups = null; if (!groupsToCreate.isEmpty()) { if (groupsFromResource != null && !groupsFromResource.isEmpty()) { prepareGroups = groupBusinessLogic.addGroups(resource, groupsToCreate); } else { prepareGroups = groupBusinessLogic.createGroups(resource, groupsToCreate); } if (prepareGroups.isRight()) { return Either.right(prepareGroups.right().value()); } } if (!groupsToDelete.isEmpty()) { prepareGroups = groupBusinessLogic.deleteGroups(resource, groupsToDelete); if (prepareGroups.isRight()) { return Either.right(prepareGroups.right().value()); } } if (groupsToUpdate != null && !groupsToUpdate.isEmpty()) { prepareGroups = groupBusinessLogic.updateGroups(resource, groupsToUpdate); if (prepareGroups.isRight()) { return Either.right(prepareGroups.right().value()); } } } else { return Either.left(resource); } Either updatedResource = toscaOperationFacade .getToscaElement(resource.getUniqueId()); if (updatedResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource); return Either.right(responseFormat); } return Either.left(updatedResource.left().value()); } private Either createInputsOnResource(Resource resource, User user, Map inputs, boolean inTransaction) { List resourceProperties = resource.getInputs(); if ((inputs != null && false == inputs.isEmpty()) || (resourceProperties != null && false == resourceProperties.isEmpty())) { Either, ResponseFormat> createInputs = inputsBusinessLogic.createInputsInGraph(inputs, resource); if (createInputs.isRight()) { return Either.right(createInputs.right().value()); } } else { return Either.left(resource); } Either updatedResource = toscaOperationFacade .getToscaElement(resource.getUniqueId()); if (updatedResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource); return Either.right(responseFormat); } return Either.left(updatedResource.left().value()); } private Either, ResponseFormat> updateGroupMembersUsingResource( Map groups, Resource component) { List result = new ArrayList<>(); List componentInstances = component.getComponentInstances(); if (groups != null) { Either validateCyclicGroupsDependencies = validateCyclicGroupsDependencies(groups); if (validateCyclicGroupsDependencies.isRight()) { return FunctionalInterfaces.convertEitherRight(validateCyclicGroupsDependencies); } for (Entry entry : groups.entrySet()) { String groupName = entry.getKey(); GroupDefinition groupDefinition = entry.getValue(); GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition); updatedGroupDefinition.setMembers(null); // get the members of the group Map members = groupDefinition.getMembers(); if (members != null) { Set compInstancesNames = members.keySet(); if (componentInstances == null || true == componentInstances.isEmpty()) { String membersAstString = compInstancesNames.stream().collect(Collectors.joining(",")); log.debug( "The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString, groupName, component.getNormalizedName()); return Either.right(componentsUtils.getResponseFormat( ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(), getComponentTypeForResponse(component))); } // Find all component instances with the member names Map memberNames = componentInstances.stream() .collect(Collectors.toMap(ComponentInstance::getName, ComponentInstance::getUniqueId)); memberNames.putAll(groups.keySet().stream().collect(Collectors.toMap(g -> g, g -> ""))); Map relevantInstances = memberNames.entrySet().stream() .filter(n -> compInstancesNames.contains(n.getKey())) .collect(Collectors.toMap(n -> n.getKey(), n -> n.getValue())); if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) { List foundMembers = new ArrayList<>(); if (relevantInstances != null) { foundMembers = relevantInstances.keySet().stream().collect(Collectors.toList()); } compInstancesNames.removeAll(foundMembers); String membersAstString = compInstancesNames.stream().collect(Collectors.joining(",")); log.debug("The members: {}, in group: {}, cannot be found in component: {}", membersAstString, groupName, component.getNormalizedName()); return Either.right(componentsUtils.getResponseFormat( ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(), getComponentTypeForResponse(component))); } updatedGroupDefinition.setMembers(relevantInstances); } result.add(updatedGroupDefinition); } } return Either.left(result); } /** * This Method validates that there is no cyclic group dependencies. meaning * group A as member in group B which is member in group A * * @param allGroups * @return */ private Either validateCyclicGroupsDependencies(Map allGroups) { Either result = Either.left(true); try { Iterator> allGroupsItr = allGroups.entrySet().iterator(); while (allGroupsItr.hasNext() && result.isLeft()) { Entry groupAEntry = allGroupsItr.next(); // Fetches a group member A String groupAName = groupAEntry.getKey(); // Finds all group members in group A Set allGroupAMembersNames = new HashSet<>(); fillAllGroupMemebersRecursivly(groupAEntry.getKey(), allGroups, allGroupAMembersNames); // If A is a group member of itself found cyclic dependency if (allGroupAMembersNames.contains(groupAName)) { ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.GROUP_HAS_CYCLIC_DEPENDENCY, groupAName); result = Either.right(responseFormat); } } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); result = Either.right(responseFormat); log.debug("Exception occured when validateCyclicGroupsDependencies, error is:{}", e.getMessage(), e); } return result; } /** * This Method fills recursively the set groupMembers with all the members * of the given group which are also of type group. * * @param groupName * @param allGroups * @param allGroupMembers * @return */ private void fillAllGroupMemebersRecursivly(String groupName, Map allGroups, Set allGroupMembers) { // Found Cyclic dependency if (isfillGroupMemebersRecursivlyStopCondition(groupName, allGroups, allGroupMembers)) { return; } GroupDefinition groupDefinition = allGroups.get(groupName); // All Members Of Current Group Resource Instances & Other Groups Set currGroupMembers = groupDefinition.getMembers().keySet(); // Filtered Members Of Current Group containing only members which // are groups List currGroupFilteredMembers = currGroupMembers.stream(). // Keep Only Elements of type group and not Resource Instances filter(innerGroupName -> allGroups.containsKey(innerGroupName)). // Add Filtered Elements to main Set peek(innerGroupName -> allGroupMembers.add(innerGroupName)). // Collect results collect(Collectors.toList()); // Recursively call the method for all the filtered group members for (String innerGroupName : currGroupFilteredMembers) { fillAllGroupMemebersRecursivly(innerGroupName, allGroups, allGroupMembers); } } private boolean isfillGroupMemebersRecursivlyStopCondition(String groupName, Map allGroups, Set allGroupMembers) { boolean stop = false; // In Case Not Group Stop if (!allGroups.containsKey(groupName)) { stop = true; } // In Case Group Has no members stop if (!stop) { GroupDefinition groupDefinition = allGroups.get(groupName); stop = MapUtils.isEmpty(groupDefinition.getMembers()); } // In Case all group members already contained stop if (!stop) { final Set allMembers = allGroups.get(groupName).getMembers().keySet(); Set membersOfTypeGroup = allMembers.stream(). // Filter In Only Group members filter(innerGroupName -> allGroups.containsKey(innerGroupName)). // Collect collect(Collectors.toSet()); stop = allGroupMembers.containsAll(membersOfTypeGroup); } return stop; } private Either createRIAndRelationsFromYaml(String yamlName, Resource resource, Map uploadComponentInstanceInfoMap, AuditingActionEnum actionEnum, String topologyTemplateYaml, List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, Map>> nodeTypesArtifactsToCreate, String nodeName) { Either result; Either createResourcesInstancesEither; log.debug("************* Going to create all nodes {}", yamlName); Either, ResponseFormat> createdResourcesFromdNodeTypeMap = this.handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName); log.debug("************* Finished to create all nodes {}", yamlName); if (createdResourcesFromdNodeTypeMap.isRight()) { log.debug("failed to resources from node types status is {}", createdResourcesFromdNodeTypeMap.right().value()); return Either.right(createdResourcesFromdNodeTypeMap.right().value()); } log.debug("************* Going to create all resource instances {}", yamlName); createResourcesInstancesEither = createResourceInstances(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap, true, false, csarInfo.getCreatedNodes()); log.debug("************* Finished to create all resource instances {}", yamlName); if (createResourcesInstancesEither.isRight()) { log.debug("failed to create resource instances status is {}", createResourcesInstancesEither.right().value()); result = createResourcesInstancesEither; return createResourcesInstancesEither; } resource = createResourcesInstancesEither.left().value(); log.debug("************* Going to create all relations {}", yamlName); createResourcesInstancesEither = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap); log.debug("************* Finished to create all relations {}", yamlName); if (createResourcesInstancesEither.isRight()) { log.debug("failed to create relation between resource instances status is {}", createResourcesInstancesEither.right().value()); result = createResourcesInstancesEither; return result; } else { resource = createResourcesInstancesEither.left().value(); } log.debug("************* Going to create positions {}", yamlName); Either, ResponseFormat> eitherSetPosition = compositionBusinessLogic .setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId()); log.debug("************* Finished to set positions {}", yamlName); result = eitherSetPosition.isRight() ? Either.right(eitherSetPosition.right().value()) : Either.left(resource); return result; } private void handleAndAddExtractedVfcsArtifacts(List vfcArtifacts, List artifactsToAdd) { List vfcArtifactNames = vfcArtifacts.stream().map(a -> a.getArtifactName()) .collect(Collectors.toList()); artifactsToAdd.stream().forEach(a -> { if (!vfcArtifactNames.contains(a.getArtifactName())) { vfcArtifacts.add(a); } else { log.error("Can't upload two artifact with the same name {}. ", a.getArtifactName()); } }); } @SuppressWarnings("unchecked") private Either, ResponseFormat> handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock, Map>> nodeTypesArtifactsToHandle, List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, String nodeName) { Either, ResponseFormat> result = Either.left(csarInfo.getCreatedNodes()); for (Entry nodeTypeEntry : nodeTypesInfo.entrySet()) { if (nodeTypeEntry.getValue().isNested()) { Either createResourceFromYaml = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypeEntry.getKey()); log.trace("************* finished to create node {}", nodeTypeEntry.getKey()); if (createResourceFromYaml.isRight()) { return Either.right(createResourceFromYaml.right().value()); } } } Map mappedToscaTemplate = null; if (StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo.containsKey(nodeName)) { mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate(); } if (MapUtils.isEmpty(mappedToscaTemplate)) { mappedToscaTemplate = (Map) new Yaml().load(topologyTemplateYaml); } Either, ResponseFormat> createdNodeTypeFromMainTemplateEither = createResourcesFromYamlNodeTypesList( yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo); if (createdNodeTypeFromMainTemplateEither.isRight()) { ResponseFormat responseFormat = createdNodeTypeFromMainTemplateEither.right().value(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return Either.right(responseFormat); } // add the created node types to the cache although they are not in the // graph. csarInfo.getCreatedNodes().values().stream() .forEach(p -> cacheManagerOperation.storeComponentInCache(p, NodeTypeEnum.Resource)); return result; } private Either handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock, boolean inTransaction) { if (csarInfo.getCsar() != null) { String vendorLicenseModelId = null; String vfLicenseModelId = null; if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) { Map deploymentArtifactsMap = resource.getDeploymentArtifacts(); if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) { for (Entry artifactEntry : deploymentArtifactsMap.entrySet()) { if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) vendorLicenseModelId = artifactEntry.getValue().getUniqueId(); if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) vfLicenseModelId = artifactEntry.getValue().getUniqueId(); } } } // Specific Behavior for license artifacts createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL, Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId, artifactOperation, null, false, shouldLock, inTransaction); createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL, ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, false, shouldLock, inTransaction); Either eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation); if (eitherCreateResult.isRight()) { return Either.right(eitherCreateResult.right().value()); } Either eitherGerResource = toscaOperationFacade .getToscaElement(resource.getUniqueId()); if (eitherGerResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource); return Either.right(responseFormat); } resource = eitherGerResource.left().value(); Either, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils.getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils); if (artifacsMetaCsarStatus.isLeft()) { String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey(); String artifactsContents = artifacsMetaCsarStatus.left().value().getValue(); Either createArtifactsFromCsar; if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock, inTransaction); else createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock, inTransaction); if (createArtifactsFromCsar.isRight()) { log.debug("Couldn't create artifacts from artifacts.meta"); return Either.right(createArtifactsFromCsar.right().value()); } return Either.left(createArtifactsFromCsar.left().value()); } else { return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction); } } return Either.left(resource); } private Either createOrUpdateSingleNonMetaArtifact(Resource resource, CsarInfo csarInfo, String artifactPath, String artifactFileName, String artifactType, ArtifactGroupTypeEnum artifactGroupType, String artifactLabel, String artifactDisplayName, String artifactDescription, String artifactId, ArtifactOperationInfo operation, List createdArtifacts, boolean isFromCsar, boolean shouldLock, boolean inTransaction) { byte[] artifactFileBytes = null; if (csarInfo.getCsar().containsKey(artifactPath)) { artifactFileBytes = csarInfo.getCsar().get(artifactPath); } Either result = Either.left(true); if (operation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE || operation.getArtifactOperationEnum() == ArtifactOperationEnum.DELETE) { if (isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) { Either, ResponseFormat> handleDelete = artifactsBusinessLogic.handleDelete(resource.getUniqueId(), artifactId, csarInfo.getModifier(), AuditingActionEnum.ARTIFACT_DELETE, ComponentTypeEnum.RESOURCE, resource, shouldLock, inTransaction); if (handleDelete.isRight()) { result = Either.right(handleDelete.right().value()); } return result; } if (StringUtils.isEmpty(artifactId) && artifactFileBytes != null) { operation = artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE); } } if (artifactFileBytes != null) { Map vendorLicenseModelJson = ArtifactUtils.buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName, artifactDescription, artifactFileBytes, null, isFromCsar); Either, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson( resource, csarInfo.getModifier(), vendorLicenseModelJson, operation); addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts); if (eitherNonMetaArtifacts.isRight()) { BeEcompErrorManager.getInstance() .logInternalFlowError("UploadLicenseArtifact", "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(), ErrorSeverity.WARNING); return Either.right(eitherNonMetaArtifacts.right().value()); } } return result; } private boolean isArtifactDeletionRequired(String artifactId, byte[] artifactFileBytes, boolean isFromCsar) { return !StringUtils.isEmpty(artifactId) && artifactFileBytes == null && isFromCsar; } private void addNonMetaCreatedArtifactsToSupportRollback(ArtifactOperationInfo operation, List createdArtifacts, Either, ResponseFormat> eitherNonMetaArtifacts) { if (ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum()) && createdArtifacts != null && eitherNonMetaArtifacts.isLeft()) { Either eitherResult = eitherNonMetaArtifacts.left().value(); if (eitherResult.isLeft()) { createdArtifacts.add(eitherResult.left().value()); } } } private Either createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource, List createdArtifacts, boolean shouldLock, boolean inTransaction, ArtifactOperationInfo artifactOperation) { Either resStatus = null; Map>> collectedWarningMessages = new HashMap<>(); try { List artifactPathAndNameList = // Stream of file paths contained in csar csarInfo.getCsar().entrySet().stream() // Filter in only VF artifact path location .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()) .matches()) // Validate and add warnings .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)) // Filter in Non Warnings .filter(e -> e.isLeft()) // Convert from Either to NonMetaArtifactInfo .map(e -> e.left().value()) // collect to List .collect(Collectors.toList()); Either responseFormatEither = validateArtifactNames(artifactPathAndNameList); if (responseFormatEither.isRight()) { return Either.right(getComponentsUtils().getResponseFormatByArtifactId( ActionStatus.ARTIFACT_NAME_INVALID, responseFormatEither.right().value())); } EnumMap> vfCsarArtifactsToHandle = null; if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) { vfCsarArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class); vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList); } else { Either>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle( resource, artifactPathAndNameList, csarInfo.getModifier()); if (findVfCsarArtifactsToHandleRes.isRight()) { resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value()); } if (resStatus == null) { vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value(); } } if (resStatus == null && vfCsarArtifactsToHandle != null) { for (Entry> currArtifactOperationPair : vfCsarArtifactsToHandle .entrySet()) { Optional optionalCreateInDBError = // Stream of artifacts to be created currArtifactOperationPair.getValue().stream() // create each artifact .map(e -> createOrUpdateSingleNonMetaArtifact(resource, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType().getType(), e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(), artifactsBusinessLogic.new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock, inTransaction)) // filter in only error .filter(e -> e.isRight()). // Convert the error from either to // ResponseFormat map(e -> e.right().value()). // Check if an error occurred findAny(); // Error found on artifact Creation if (optionalCreateInDBError.isPresent()) { resStatus = Either.right(optionalCreateInDBError.get()); break; } } } if (resStatus == null) { resStatus = Either.left(resource); } } catch (Exception e) { resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e); } finally { CsarUtils.handleWarningMessages(collectedWarningMessages); } return resStatus; } private Either validateArtifactNames(List artifactPathAndNameList) { Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME); for (NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) { if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) { return Either.right(nonMetaArtifactInfo.getArtifactName()); } } return Either.left(true); } private Either>, ResponseFormat> findVfCsarArtifactsToHandle( Resource resource, List artifactPathAndNameList, User user) { List existingArtifacts = new ArrayList<>(); // collect all Deployment and Informational artifacts of VF if (resource.getDeploymentArtifacts() != null && !resource.getDeploymentArtifacts().isEmpty()) { existingArtifacts.addAll(resource.getDeploymentArtifacts().values()); } if (resource.getArtifacts() != null && !resource.getArtifacts().isEmpty()) { existingArtifacts.addAll(resource.getArtifacts().values()); } existingArtifacts = existingArtifacts.stream() // filter MANDATORY artifacts, LICENSE artifacts and artifacts // was created from HEAT.meta .filter(this::isNonMetaArtifact).collect(Collectors.toList()); List artifactsToIgnore = new ArrayList<>(); // collect IDs of Artifacts of VF which belongs to any group if (resource.getGroups() != null) { resource.getGroups().stream().forEach(g -> { if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) artifactsToIgnore.addAll(g.getArtifacts()); }); } existingArtifacts = existingArtifacts.stream() // filter artifacts which belongs to any group .filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(Collectors.toList()); return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, resource, user); } private boolean isNonMetaArtifact(ArtifactDefinition artifact) { boolean result = true; if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) { result = false; } return result; } private boolean isValidArtifactType(ArtifactDefinition artifact) { boolean result = true; if (artifact.getArtifactType() == null || ArtifactTypeEnum.findType(artifact.getArtifactType()) == ArtifactTypeEnum.VENDOR_LICENSE || ArtifactTypeEnum.findType(artifact.getArtifactType()) == ArtifactTypeEnum.VF_LICENSE) { result = false; } return result; } private Either createResourceInstancesRelations(User user, String yamlName, Resource resource, Map uploadResInstancesMap) { log.debug("createResourceInstancesRelations try to create relations "); List componentInstancesList = resource.getComponentInstances(); if (uploadResInstancesMap == null) { log.debug("UploadComponentInstanceInfo is empty, fileName {}", yamlName); BeEcompErrorManager.getInstance().logInternalDataError("UploadComponentInstanceInfo is emty, fileName {}", yamlName, ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return Either.right(responseFormat); } if (componentInstancesList == null || componentInstancesList.isEmpty()) { log.debug("componentInstancesList is empty in resource {} ", resource.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError("componentInstancesList is empty in resource {} ", resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return Either.right(responseFormat); } log.debug("Before validateAndUpdatePropertyValue"); Either, TitanOperationStatus> allDataTypes = dataTypeCache.getAll(); if (allDataTypes.isRight()) { TitanOperationStatus status = allDataTypes.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR); return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse( DaoStatusConverter.convertTitanStatusToStorageStatus(status)), yamlName)); } Map> instProperties = new HashMap<>(); Map>> instCapabilties = new HashMap<>(); Map>> instRequirements = new HashMap<>(); Map> instDeploymentArtifacts = new HashMap<>(); Map> instArtifacts = new HashMap<>(); Map> instAttributes = new HashMap<>(); Map originCompMap = new HashMap<>(); List relations = new ArrayList<>(); Map> instInputs = new HashMap<>(); for (Entry entry : uploadResInstancesMap.entrySet()) { log.trace("Processing entry: {}", entry); UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue(); ComponentInstance currentCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { log.trace("Processing component instance: {}", compInstance); if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) { currentCompInstance = compInstance; break; } } if (currentCompInstance == null) { log.debug("component instance with name {} in resource {} ", uploadComponentInstanceInfo.getName(), resource.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError( "component instance with name " + uploadComponentInstanceInfo.getName() + " in resource {} ", resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return Either.right(responseFormat); } String resourceInstanceId = currentCompInstance.getUniqueId(); Resource originResource; if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) { Either getOriginResourceRes = toscaOperationFacade .getToscaFullElement(currentCompInstance.getComponentUid()); if (getOriginResourceRes.isRight()) { log.debug("failed to fetch resource with uniqueId {} and tosca component name {} status is {}", currentCompInstance.getComponentUid(), currentCompInstance.getToscaComponentName(), getOriginResourceRes); ResponseFormat responseFormat = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName); return Either.right(responseFormat); } originResource = getOriginResourceRes.left().value(); originCompMap.put(originResource.getUniqueId(), originResource); } else { originResource = originCompMap.get(currentCompInstance.getComponentUid()); } if (originResource.getRequirements() != null && !originResource.getRequirements().isEmpty()) instRequirements.put(currentCompInstance, originResource.getRequirements()); if (MapUtils.isNotEmpty(originResource.getCapabilities())) { Map> originCapabilities; if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) { originCapabilities = new HashMap<>(); originResource.getCapabilities().entrySet().stream().forEach(e -> { List list = e.getValue().stream().map(l -> new CapabilityDefinition(l)) .collect(Collectors.toList()); originCapabilities.put(e.getKey(), list); }); Map> newPropertiesMap = new HashMap<>(); for (List capabilities : uploadComponentInstanceInfo.getCapabilities().values()) { for (UploadCapInfo capability : capabilities) { if (CollectionUtils.isNotEmpty(capability.getProperties())) { newPropertiesMap.put(capability.getName(), capability.getProperties().stream() .collect(Collectors.toMap(p -> p.getName(), p -> p))); } } } for (List capabilities : originCapabilities.values()) { List filteredCapabilities = capabilities.stream() .filter(c -> newPropertiesMap.containsKey(c.getName())).collect(Collectors.toList()); for (CapabilityDefinition cap : filteredCapabilities) { Either updateRes = updatePropertyValues(cap.getProperties(), newPropertiesMap.get(cap.getName()), allDataTypes.left().value()); if (updateRes.isRight()) { log.debug("Failed to update capability properties of capability {} . Status is {}. ", cap.getName(), updateRes.right().value()); return Either.right(updateRes.right().value()); } } } } else { originCapabilities = originResource.getCapabilities(); } instCapabilties.put(currentCompInstance, originCapabilities); } if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts()); if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) instArtifacts.put(resourceInstanceId, originResource.getArtifacts()); if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) instAttributes.put(resourceInstanceId, originResource.getAttributes()); if (originResource.getResourceType() != ResourceTypeEnum.CVFC) { ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance, yamlName, instProperties, allDataTypes.left().value()); if (addPropertiesValueToRiRes.getStatus() != 200) { return Either.right(addPropertiesValueToRiRes); } } else { ResponseFormat addInputValueToRiRes = addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance, yamlName, instInputs, allDataTypes.left().value()); if (addInputValueToRiRes.getStatus() != 200) { return Either.right(addInputValueToRiRes); } } } Either>, StorageOperationStatus> addPropToInst = toscaOperationFacade .associateComponentInstancePropertiesToComponent(instProperties, resource.getUniqueId()); if (addPropToInst.isRight()) { log.debug("failed to associate properties of resource {} status is {}", resource.getUniqueId(), addPropToInst.right().value()); ResponseFormat responseFormat = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(addPropToInst.right().value()), yamlName); return Either.right(responseFormat); } if (instInputs != null && !instInputs.isEmpty()) { Either>, StorageOperationStatus> addInputToInst = toscaOperationFacade .associateComponentInstanceInputsToComponent(instInputs, resource.getUniqueId()); if (addInputToInst.isRight()) { log.debug("failed to associate inputs value of resource {} status is {}", resource.getUniqueId(), addInputToInst.right().value()); ResponseFormat responseFormat = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(addInputToInst.right().value()), yamlName); return Either.right(responseFormat); } } StorageOperationStatus addArtToInst = toscaOperationFacade .associateDeploymentArtifactsToInstances(instDeploymentArtifacts, resource.getUniqueId(), user); if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) { log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName); return Either.right(responseFormat); } addArtToInst = toscaOperationFacade.associateArtifactsToInstances(instArtifacts, resource.getUniqueId(), user); if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) { log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName); return Either.right(responseFormat); } addArtToInst = toscaOperationFacade.associateCalculatedCapReq(instCapabilties, instRequirements, resource.getUniqueId()); if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) { log.debug("failed to associate cap and req of resource {} status is {}", resource.getUniqueId(), addArtToInst); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName); return Either.right(responseFormat); } addArtToInst = toscaOperationFacade.associateInstAttributeToComponentToInstances(instAttributes, resource.getUniqueId()); if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) { log.debug("failed to associate attributes of resource {} status is {}", resource.getUniqueId(), addArtToInst); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName); return Either.right(responseFormat); } ComponentParametersView parametersView = new ComponentParametersView(); parametersView.disableAll(); parametersView.setIgnoreComponentInstances(false); parametersView.setIgnoreComponentInstancesProperties(false); parametersView.setIgnoreCapabilities(false); parametersView.setIgnoreRequirements(false); Either eitherGetResource = toscaOperationFacade .getToscaElement(resource.getUniqueId(), parametersView); if (eitherGetResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); return Either.right(responseFormat); } resource = eitherGetResource.left().value(); for (Entry entry : uploadResInstancesMap.entrySet()) { UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue(); ComponentInstance currentCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) { currentCompInstance = compInstance; break; } } if (currentCompInstance == null) { log.debug("component instance with name {} in resource {} ", uploadComponentInstanceInfo.getName(), resource.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError( "component instance with name " + uploadComponentInstanceInfo.getName() + " in resource {} ", resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return Either.right(responseFormat); } ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, resource, entry.getValue(), relations); if (addRelationToRiRes.getStatus() != 200) { return Either.right(addRelationToRiRes); } } addArtToInst = toscaOperationFacade.associateResourceInstances(resource.getUniqueId(), relations); if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) { log.debug("failed to associate instances of resource {} status is {}", resource.getUniqueId(), addArtToInst); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName); return Either.right(responseFormat); } if (resource.getResourceType() == ResourceTypeEnum.CVFC) { eitherGetResource = toscaOperationFacade.getToscaFullElement(resource.getUniqueId()); if (eitherGetResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); return Either.right(responseFormat); } eitherGetResource = updateCalculatedCapReqWithSubstitutionMappings(eitherGetResource.left().value(), uploadResInstancesMap); if (eitherGetResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); return Either.right(responseFormat); } } log.debug("************* in create relations, getResource start"); eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId()); log.debug("************* in create relations, getResource end"); if (eitherGetResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); return Either.right(responseFormat); } return Either.left(eitherGetResource.left().value()); } private Either updatePropertyValues(List properties, Map newProperties, Map allDataTypes) { for (ComponentInstanceProperty property : properties) { Either updateRes = updatePropertyValue(property, newProperties.get(property.getName()), allDataTypes); if (updateRes.isRight()) { log.debug("Failed to update capability property {} . Status is {}. ", property.getName(), updateRes.right().value()); return Either.right(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(updateRes.right().value()))); } } return Either.left(true); } private Either updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo, Map allDataTypes) { String value = null; List getInputs = null; boolean isValidate = true; if (null != propertyInfo && propertyInfo.getValue() != null) { getInputs = propertyInfo.getGet_input(); isValidate = getInputs == null || getInputs.isEmpty(); if (isValidate) { value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), property.getType()); } else value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), ToscaTagNamesEnum.GET_INPUT.getElementName()); } property.setValue(value); return validatePropValueBeforeCreate(property, value, isValidate, null, allDataTypes); } private Either updateCalculatedCapReqWithSubstitutionMappings(Resource resource, Map uploadResInstancesMap) { Either updateRes = null; Map>> updatedInstCapabilities = new HashMap<>(); Map>> updatedInstRequirements = new HashMap<>(); StorageOperationStatus status = toscaOperationFacade .deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId()); if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { log.debug( "Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}", resource.getUniqueId(), status); updateRes = Either.right(status); } if (updateRes == null) { fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities, updatedInstRequirements); status = toscaOperationFacade.associateCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource.getUniqueId()); if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { log.debug( "Failed to associate capabilities and requirementss of resource {}, updated according to a substitution mapping. Status is {}", resource.getUniqueId(), status); updateRes = Either.right(status); } } if (updateRes == null) { updateRes = Either.left(resource); } return updateRes; } private void fillUpdatedInstCapabilitiesRequirements(List componentInstances, Map uploadResInstancesMap, Map>> updatedInstCapabilities, Map>> updatedInstRequirements) { componentInstances.stream().forEach(i -> { fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate()); fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate()); }); } private void fillUpdatedInstRequirements( Map>> updatedInstRequirements, ComponentInstance instance, Map requirementsNamesToUpdate) { Map> updatedRequirements = new HashMap<>(); Set updatedReqNames = new HashSet<>(); if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) { for (Map.Entry> requirements : instance.getRequirements().entrySet()) { updatedRequirements.put(requirements.getKey(), requirements.getValue().stream() .filter(r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName()))) .map(r -> { r.setParentName(r.getName()); r.setName(requirementsNamesToUpdate.get(r.getName())); updatedReqNames.add(r.getName()); return r; }).collect(Collectors.toList())); } } if (MapUtils.isNotEmpty(updatedRequirements)) { updatedInstRequirements.put(instance, updatedRequirements); } } private void fillUpdatedInstCapabilities( Map>> updatedInstCapabilties, ComponentInstance instance, Map capabilitiesNamesToUpdate) { Map> updatedCapabilities = new HashMap<>(); Set updatedCapNames = new HashSet<>(); if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) { for (Map.Entry> requirements : instance.getCapabilities().entrySet()) { updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream() .filter(c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName()))) .map(c -> { c.setParentName(c.getName()); c.setName(capabilitiesNamesToUpdate.get(c.getName())); updatedCapNames.add(c.getName()); return c; }).collect(Collectors.toList())); } } if (MapUtils.isNotEmpty(updatedCapabilities)) { updatedInstCapabilties.put(instance, updatedCapabilities); } } private ResponseFormat addRelationToRI(String yamlName, Resource resource, UploadComponentInstanceInfo nodesInfoValue, List relations) { List componentInstancesList = resource.getComponentInstances(); UploadComponentInstanceInfo uploadComponentInstanceInfo = nodesInfoValue; ComponentInstance currentCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) { currentCompInstance = compInstance; break; } } if (currentCompInstance == null) { log.debug("component instance with name {} in resource {} ", uploadComponentInstanceInfo.getName(), resource.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError( "component instance with name " + uploadComponentInstanceInfo.getName() + " in resource {} ", resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return responseFormat; } String resourceInstanceId = currentCompInstance.getUniqueId(); Map> regMap = uploadComponentInstanceInfo.getRequirements(); if (regMap != null) { Iterator>> nodesRegValue = regMap.entrySet().iterator(); while (nodesRegValue.hasNext()) { Entry> nodesRegInfoEntry = nodesRegValue.next(); List uploadRegInfoList = nodesRegInfoEntry.getValue(); for (UploadReqInfo uploadRegInfo : uploadRegInfoList) { log.debug("Going to create relation {}", uploadRegInfo.getName()); String regName = uploadRegInfo.getName(); RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef(); regCapRelDef.setFromNode(resourceInstanceId); log.debug("try to find available requirement {} ", regName); Either eitherReqStatus = findAviableRequiremen(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, uploadRegInfo.getCapabilityName()); if (eitherReqStatus.isRight()) { log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value()); return eitherReqStatus.right().value(); } RequirementDefinition validReq = eitherReqStatus.left().value(); List reqAndRelationshipPairList = regCapRelDef .getRelationships(); if (reqAndRelationshipPairList == null) reqAndRelationshipPairList = new ArrayList<>(); RelationshipInfo reqAndRelationshipPair = new RelationshipInfo(); reqAndRelationshipPair.setRequirement(regName); reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId()); reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId()); RelationshipImpl relationship = new RelationshipImpl(); relationship.setType(validReq.getCapability()); reqAndRelationshipPair.setRelationships(relationship); ComponentInstance currentCapCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { if (compInstance.getName().equals(uploadRegInfo.getNode())) { currentCapCompInstance = compInstance; break; } } if (currentCapCompInstance == null) { log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), resource.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError( "component instance with name " + uploadRegInfo.getNode() + " in resource {} ", resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return responseFormat; } regCapRelDef.setToNode(currentCapCompInstance.getUniqueId()); log.debug("try to find aviable Capability req name is {} ", validReq.getName()); CapabilityDefinition aviableCapForRel = findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo); if (aviableCapForRel == null) { log.debug("aviable capability was not found. req name is {} component instance is {}", validReq.getName(), currentCapCompInstance.getUniqueId()); BeEcompErrorManager.getInstance().logInternalDataError( "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance.getUniqueId(), resource.getUniqueId(), ErrorSeverity.ERROR); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); return responseFormat; } reqAndRelationshipPair.setCapability(aviableCapForRel.getName()); reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId()); reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId()); CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship(); capReqRel.setRelation(reqAndRelationshipPair); reqAndRelationshipPairList.add(capReqRel); regCapRelDef.setRelationships(reqAndRelationshipPairList); relations.add(regCapRelDef); } } } else if (resource.getResourceType() != ResourceTypeEnum.CVFC) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK, yamlName); return responseFormat; } return componentsUtils.getResponseFormat(ActionStatus.OK); } private ResponseFormat addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Resource resource, Resource originResource, ComponentInstance currentCompInstance, String yamlName, Map> instInputs, Map allDataTypes) { Map> propMap = uploadComponentInstanceInfo.getProperties(); if (propMap != null && propMap.size() > 0) { Map currPropertiesMap = new HashMap(); List listFromMap = originResource.getInputs(); if (listFromMap == null || listFromMap.isEmpty()) { log.debug("failed to find properties "); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND); return responseFormat; } for (InputDefinition prop : listFromMap) { String propName = prop.getName(); if (!currPropertiesMap.containsKey(propName)) { currPropertiesMap.put(propName, prop); } } List instPropList = new ArrayList<>(); for (List propertyList : propMap.values()) { UploadPropInfo propertyInfo = propertyList.get(0); String propName = propertyInfo.getName(); if (!currPropertiesMap.containsKey(propName)) { log.debug("failed to find property {} ", propName); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName); return responseFormat; } InputDefinition curPropertyDef = currPropertiesMap.get(propName); ComponentInstanceInput property = null; String value = null; List getInputs = null; boolean isValidate = true; if (propertyInfo.getValue() != null) { getInputs = propertyInfo.getGet_input(); isValidate = getInputs == null || getInputs.isEmpty(); if (isValidate) { value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType()); } else value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), ToscaTagNamesEnum.GET_INPUT.getElementName()); } String innerType = null; property = new ComponentInstanceInput(curPropertyDef, value, null); Either validatevalueEiter = validatePropValueBeforeCreate(property, value, isValidate, innerType, allDataTypes); if (validatevalueEiter.isRight()) { return componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(validatevalueEiter.right().value())); } property.setValue(validatevalueEiter.left().value()); if (getInputs != null && !getInputs.isEmpty()) { List getInputValues = new ArrayList<>(); for (GetInputValueDataDefinition getInput : getInputs) { List inputs = resource.getInputs(); if (inputs == null || inputs.isEmpty()) { log.debug("Failed to add property {} to resource instance {}. Inputs list is empty ", property, currentCompInstance.getUniqueId()); return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } Optional optional = inputs.stream() .filter(p -> p.getName().equals(getInput.getInputName())).findAny(); if (!optional.isPresent()) { log.debug("Failed to find input {} ", getInput.getInputName()); // @@TODO error message return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } InputDefinition input = optional.get(); getInput.setInputId(input.getUniqueId()); getInputValues.add(getInput); GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex(); if (getInputIndex != null) { optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())) .findAny(); if (!optional.isPresent()) { log.debug("Failed to find input {} ", getInputIndex.getInputName()); // @@TODO error message return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } InputDefinition inputIndex = optional.get(); getInputIndex.setInputId(inputIndex.getUniqueId()); getInputValues.add(getInputIndex); } } property.setGetInputValues(getInputValues); } instPropList.add(property); // delete overriden property currPropertiesMap.remove(property.getName()); } // add rest of properties if (!currPropertiesMap.isEmpty()) { for (InputDefinition value : currPropertiesMap.values()) { instPropList.add(new ComponentInstanceInput(value)); } } instInputs.put(currentCompInstance.getUniqueId(), instPropList); } return componentsUtils.getResponseFormat(ActionStatus.OK); } private ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Resource resource, Resource originResource, ComponentInstance currentCompInstance, String yamlName, Map> instProperties, Map allDataTypes) { Map> propMap = uploadComponentInstanceInfo.getProperties(); Map currPropertiesMap = new HashMap(); List listFromMap = originResource.getProperties(); if ((propMap != null && !propMap.isEmpty()) && (listFromMap == null || listFromMap.isEmpty())) { log.debug("failed to find properties "); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND); return responseFormat; } if (listFromMap == null || listFromMap.isEmpty()) { return componentsUtils.getResponseFormat(ActionStatus.OK); } for (PropertyDefinition prop : listFromMap) { String propName = prop.getName(); if (!currPropertiesMap.containsKey(propName)) { currPropertiesMap.put(propName, prop); } } List instPropList = new ArrayList<>(); if (propMap != null && propMap.size() > 0) { for (List propertyList : propMap.values()) { UploadPropInfo propertyInfo = propertyList.get(0); String propName = propertyInfo.getName(); if (!currPropertiesMap.containsKey(propName)) { log.debug("failed to find property {} ", propName); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName); return responseFormat; } PropertyDefinition curPropertyDef = currPropertiesMap.get(propName); ComponentInstanceProperty property = null; String value = null; List getInputs = null; boolean isValidate = true; if (propertyInfo.getValue() != null) { getInputs = propertyInfo.getGet_input(); isValidate = getInputs == null || getInputs.isEmpty(); if (isValidate) { value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType()); } else value = ImportUtils.getPropertyJsonStringValue(propertyInfo.getValue(), ToscaTagNamesEnum.GET_INPUT.getElementName()); } String innerType = null; property = new ComponentInstanceProperty(curPropertyDef, value, null); Either validatevalueEiter = validatePropValueBeforeCreate(property, value, isValidate, innerType, allDataTypes); if (validatevalueEiter.isRight()) { return componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(validatevalueEiter.right().value())); } property.setValue(validatevalueEiter.left().value()); if (getInputs != null && !getInputs.isEmpty()) { List getInputValues = new ArrayList<>(); for (GetInputValueDataDefinition getInput : getInputs) { List inputs = resource.getInputs(); if (inputs == null || inputs.isEmpty()) { log.debug("Failed to add property {} to resource instance {}. Inputs list is empty ", property, currentCompInstance.getUniqueId()); return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } Optional optional = inputs.stream() .filter(p -> p.getName().equals(getInput.getInputName())).findAny(); if (!optional.isPresent()) { log.debug("Failed to find input {} ", getInput.getInputName()); // @@TODO error message return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } InputDefinition input = optional.get(); getInput.setInputId(input.getUniqueId()); getInputValues.add(getInput); GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex(); if (getInputIndex != null) { optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())) .findAny(); if (!optional.isPresent()) { log.debug("Failed to find input {} ", getInputIndex.getInputName()); // @@TODO error message return componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); } InputDefinition inputIndex = optional.get(); getInputIndex.setInputId(inputIndex.getUniqueId()); getInputValues.add(getInputIndex); } } property.setGetInputValues(getInputValues); } instPropList.add(property); // delete overriden property currPropertiesMap.remove(property.getName()); } } // add rest of properties if (!currPropertiesMap.isEmpty()) { for (PropertyDefinition value : currPropertiesMap.values()) { instPropList.add(new ComponentInstanceProperty(value)); } } instProperties.put(currentCompInstance.getUniqueId(), instPropList); return componentsUtils.getResponseFormat(ActionStatus.OK); } // US740820 Relate RIs according to capability name private CapabilityDefinition findAvailableCapabilityByTypeOrName(RequirementDefinition validReq, ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) { if (null == uploadReqInfo.getCapabilityName() || validReq.getCapability().equals(uploadReqInfo.getCapabilityName())) {// get // by // capability // type return findAviableCapability(validReq, currentCapCompInstance); } return findAvailableCapability(validReq, currentCapCompInstance, uploadReqInfo); } private CapabilityDefinition findAvailableCapability(RequirementDefinition validReq, ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) { CapabilityDefinition cap = null; Map> capMap = currentCapCompInstance.getCapabilities(); if (!capMap.containsKey(validReq.getCapability())) { return null; } Optional capByName = capMap.get(validReq.getCapability()).stream() .filter(p -> p.getName().equals(uploadReqInfo.getCapabilityName())).findAny(); if (!capByName.isPresent()) { return null; } cap = capByName.get(); if (cap.getMaxOccurrences() != null && !cap.getMaxOccurrences().equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { String leftOccurrences = cap.getLeftOccurrences(); int left = Integer.parseInt(leftOccurrences); if (left > 0) { --left; cap.setLeftOccurrences(String.valueOf(left)); } } return cap; } private CapabilityDefinition findAviableCapability(RequirementDefinition validReq, ComponentInstance currentCapCompInstance) { CapabilityDefinition aviableCapForRel = null; Map> capMap = currentCapCompInstance.getCapabilities(); if (capMap.containsKey(validReq.getCapability())) { List capList = capMap.get(validReq.getCapability()); for (CapabilityDefinition cap : capList) { if (cap.getMaxOccurrences() != null && !cap.getMaxOccurrences().equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { String leftOccurrences = cap.getLeftOccurrences(); if (leftOccurrences == null) { leftOccurrences = cap.getMaxOccurrences(); } int left = Integer.parseInt(leftOccurrences); if (left > 0) { --left; cap.setLeftOccurrences(String.valueOf(left)); aviableCapForRel = cap; break; } else { continue; } } else { aviableCapForRel = cap; break; } } } return aviableCapForRel; } private Either findAviableRequiremen(String regName, String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance, String capName) { Map> comInstRegDefMap = currentCompInstance.getRequirements(); List list = comInstRegDefMap.get(capName); RequirementDefinition validRegDef = null; if (list == null) { for (Entry> entry : comInstRegDefMap.entrySet()) { for (RequirementDefinition reqDef : entry.getValue()) { if (reqDef.getName().equals(regName)) { if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences().equals(RequirementDataDefinition.MAX_OCCURRENCES)) { String leftOccurrences = reqDef.getLeftOccurrences(); if (leftOccurrences == null) { leftOccurrences = reqDef.getMaxOccurrences(); } int left = Integer.parseInt(leftOccurrences); if (left > 0) { --left; reqDef.setLeftOccurrences(String.valueOf(left)); validRegDef = reqDef; break; } else { continue; } } else { validRegDef = reqDef; break; } } } if (validRegDef != null) { break; } } } else { for (RequirementDefinition reqDef : list) { if (reqDef.getName().equals(regName)) { if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences().equals(RequirementDataDefinition.MAX_OCCURRENCES)) { String leftOccurrences = reqDef.getLeftOccurrences(); if (leftOccurrences == null) { leftOccurrences = reqDef.getMaxOccurrences(); } int left = Integer.parseInt(leftOccurrences); if (left > 0) { --left; reqDef.setLeftOccurrences(String.valueOf(left)); validRegDef = reqDef; break; } else { continue; } } else { validRegDef = reqDef; break; } } } } if (validRegDef == null) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); return Either.right(responseFormat); } return Either.left(validRegDef); } @SuppressWarnings("unchecked") public Either parseResourceInfoFromYaml(String yamlFileName, Resource resource, String resourceYml, Map createdNodesToscaResourceNames, Map nodeTypesInfo, String nodeName) { Map mappedToscaTemplate; if (nodeTypesInfo != null && nodeName != null && nodeTypesInfo.containsKey(nodeName)) { mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate(); } else { try { // DE154502 Fail if duplicate key found in file mappedToscaTemplate = ImportUtils.loadYamlAsStrictMap(resourceYml); } catch (ParserException e) { log.error("Failed to load yaml file {}", yamlFileName, e); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.TOSCA_PARSE_ERROR, yamlFileName, e.getMessage()); return Either.right(responseFormat); } } Either toscaElementEither = ImportUtils.findToscaElement(mappedToscaTemplate, ToscaTagNamesEnum.TOPOLOGY_TEMPLATE, ToscaElementTypeEnum.ALL); if (toscaElementEither.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE); return Either.right(responseFormat); } Either, ResponseFormat> createInputsEither = createInputsFromYaml(yamlFileName, mappedToscaTemplate, resource); if (createInputsEither.isRight()) { ResponseFormat responseFormat = createInputsEither.right().value(); return Either.right(responseFormat); } Either, ResponseFormat> uploadResInstancesEither = createResourcesInstanceInfoFromYaml( yamlFileName, mappedToscaTemplate, resource, createdNodesToscaResourceNames); if (uploadResInstancesEither.isRight()) { ResponseFormat responseFormat = uploadResInstancesEither.right().value(); return Either.right(responseFormat); } Either, ResponseFormat> createGroupsFromYaml = createGroupsFromYaml(yamlFileName, mappedToscaTemplate, resource); if (createGroupsFromYaml.isRight()) { ResponseFormat responseFormat = createGroupsFromYaml.right().value(); return Either.right(responseFormat); } ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo(); parsedToscaYamlInfo.setInputs(createInputsEither.left().value()); parsedToscaYamlInfo.setInstances(uploadResInstancesEither.left().value()); parsedToscaYamlInfo.setGroups(createGroupsFromYaml.left().value()); return Either.left(parsedToscaYamlInfo); } private Either createResourceInstances(User user, String yamlName, Resource resource, Map uploadResInstancesMap, boolean inTransaction, boolean needLock, Map nodeNamespaceMap) { Either eitherResource = null; log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName); if (uploadResInstancesMap == null || uploadResInstancesMap.isEmpty()) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE); return Either.right(responseFormat); } Map existingnodeTypeMap = new HashMap<>(); if (nodeNamespaceMap != null && !nodeNamespaceMap.isEmpty()) { nodeNamespaceMap.entrySet().stream() .forEach(x -> existingnodeTypeMap.put(x.getValue().getToscaResourceName(), x.getValue())); } Iterator> nodesInfoValue = uploadResInstancesMap.entrySet() .iterator(); Map resourcesInstancesMap = new HashMap<>(); while (nodesInfoValue.hasNext()) { log.debug("*************Going to create resource instances {}", yamlName); Entry uploadComponentInstanceInfoEntry = nodesInfoValue.next(); UploadComponentInstanceInfo uploadComponentInstanceInfo = uploadComponentInstanceInfoEntry.getValue(); // updating type if the type is node type name - we need to take the // updated name log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName()); if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) { uploadComponentInstanceInfo .setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName()); } eitherResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap); if (eitherResource.isRight()) { return eitherResource; } Resource refResource = eitherResource.left().value(); ComponentInstance componentInstance = new ComponentInstance(); componentInstance.setComponentUid(refResource.getUniqueId()); ComponentTypeEnum containerComponentType = resource.getComponentType(); NodeTypeEnum containerNodeType = containerComponentType.getNodeType(); if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils.isNotEmpty(refResource.getCapabilities())) { setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities()); Either>, ResponseFormat> getValidComponentInstanceCapabilitiesRes = getValidComponentInstanceCapabilities( refResource.getUniqueId(), refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities()); if (getValidComponentInstanceCapabilitiesRes.isRight()) { return Either.right(getValidComponentInstanceCapabilitiesRes.right().value()); } else { componentInstance.setCapabilities(getValidComponentInstanceCapabilitiesRes.left().value()); } } if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) { log.debug( "createResourceInstances - not found lates version for resource instance with name {} and type ", uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); return Either.right(responseFormat); } Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType()); componentInstance.setName(uploadComponentInstanceInfo.getName()); componentInstance.setIcon(origResource.getIcon()); resourcesInstancesMap.put(componentInstance, origResource); } if (MapUtils.isNotEmpty(resourcesInstancesMap)) { StorageOperationStatus status = toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false); if (status != null && status != StorageOperationStatus.OK) { log.debug("Failed to add component instances to container component {}", resource.getName()); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(status)); eitherResource = Either.right(responseFormat); return eitherResource; } } log.debug("*************Going to get resource {}", resource.getUniqueId()); ComponentParametersView parametersView = new ComponentParametersView(); parametersView.disableAll(); parametersView.setIgnoreComponentInstances(false); parametersView.setIgnoreUsers(false); parametersView.setIgnoreInputs(false); // inputs are read when creating // property values on instances Either eitherGerResource = toscaOperationFacade .getToscaElement(resource.getUniqueId(), parametersView); log.debug("*************finished to get resource {}", resource.getUniqueId()); if (eitherGerResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource); return Either.right(responseFormat); } if (eitherGerResource.left().value().getComponentInstances() == null || eitherGerResource.left().value().getComponentInstances().isEmpty()) { log.debug("Error when create resource inctanse from csar. ComponentInstances list empty"); BeEcompErrorManager.getInstance().logBeDaoSystemError( "Error when create resource inctanse from csar. ComponentInstances list empty"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE); return Either.right(responseFormat); } return Either.left(eitherGerResource.left().value()); } private void setCapabilityNamesTypes(Map> originCapabilities, Map> uploadedCapabilities) { for (Entry> currEntry : uploadedCapabilities.entrySet()) { if (originCapabilities.containsKey(currEntry.getKey())) { currEntry.getValue().stream().forEach(cap -> cap.setType(currEntry.getKey())); } } for (Map.Entry> capabilities : originCapabilities.entrySet()) { capabilities.getValue().stream().forEach(cap -> { if (uploadedCapabilities.containsKey(cap.getName())) { uploadedCapabilities.get(cap.getName()).stream().forEach(c -> { c.setName(cap.getName()); c.setType(cap.getType()); }); } ; }); } } private Either validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo, Map nodeNamespaceMap) { log.debug( "validateResourceInstanceBeforeCreate - going to validate resource instance with name {} and type before create", uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); Resource refResource = null; if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) { refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()); } else { Either findResourceEither = toscaOperationFacade .getLatestCertifiedNodeTypeByToscaResourceName(uploadComponentInstanceInfo.getType()); if (findResourceEither.isRight()) { log.debug( "validateResourceInstanceBeforeCreate - not found lates version for resource instance with name {} and type ", uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); ResponseFormat responseFormat = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(findResourceEither.right().value())); return Either.right(responseFormat); } refResource = findResourceEither.left().value(); nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource); } String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState(); if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { log.debug( "validateResourceInstanceBeforeCreate - component instance of component {} can not be created because the component is in an illegal state {}.", refResource.getName(), componentState); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(), componentState); return Either.right(responseFormat); } if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.CVFC) { log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType()); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); return Either.right(responseFormat); } return Either.left(refResource); } private Either, ResponseFormat> createResourcesInstanceInfoFromYaml( String yamlFileName, Map toscaJson, Resource resource, Map createdNodesToscaResourceNames) { Map moduleComponentInstances = new HashMap(); Map substitutionMappings = null; Either, ResponseFormat> result = Either.left(moduleComponentInstances); Either, ResultStatusEnum> eitherNodesTemlates = ImportUtils .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.NODE_TEMPLATES); Either, ResultStatusEnum> eitherSubstitutionMappings = ImportUtils .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.SUBSTITUTION_MAPPINGS); if (eitherSubstitutionMappings.isLeft()) { substitutionMappings = eitherSubstitutionMappings.left().value(); } if (eitherNodesTemlates.isLeft()) { Map jsonNodeTemplates = eitherNodesTemlates.left().value(); Iterator> nodesNameValue = jsonNodeTemplates.entrySet().iterator(); while (nodesNameValue.hasNext()) { Entry nodeNameValue = nodesNameValue.next(); Either eitherNode = createModuleComponentInstanceInfo( nodeNameValue, substitutionMappings, createdNodesToscaResourceNames); if (eitherNode.isRight()) { log.info("error when creating node template:{}, for resource:{}", nodeNameValue.getKey(), resource.getName()); return Either.right(eitherNode.right().value()); } else { UploadComponentInstanceInfo uploadComponentInstanceInfo = eitherNode.left().value(); moduleComponentInstances.put(nodeNameValue.getKey(), uploadComponentInstanceInfo); } } } if (moduleComponentInstances.isEmpty()) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName); return Either.right(responseFormat); } return result; } @SuppressWarnings("unchecked") private Either createModuleComponentInstanceInfo( Entry nodeTemplateJsonEntry, Map substitutionMappings, Map createdNodesToscaResourceNames) { UploadComponentInstanceInfo nodeTemplateInfo = new UploadComponentInstanceInfo(); Either result = Either.left(nodeTemplateInfo); nodeTemplateInfo.setName(nodeTemplateJsonEntry.getKey()); try { if (nodeTemplateJsonEntry.getValue() instanceof String) { String nodeTemplateJsonString = (String) nodeTemplateJsonEntry.getValue(); nodeTemplateInfo.setType(nodeTemplateJsonString); } else if (nodeTemplateJsonEntry.getValue() instanceof Map) { Map nodeTemplateJsonMap = (Map) nodeTemplateJsonEntry.getValue(); // Type if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.TYPE.getElementName())) { String toscaResourceType = (String) nodeTemplateJsonMap .get(ToscaTagNamesEnum.TYPE.getElementName()); if (createdNodesToscaResourceNames.containsKey(toscaResourceType)) { toscaResourceType = createdNodesToscaResourceNames.get(toscaResourceType); } nodeTemplateInfo.setType(toscaResourceType); } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.REQUIREMENTS.getElementName())) { Either>, ResponseFormat> regResponse = createReqModuleFromYaml( nodeTemplateInfo, nodeTemplateJsonMap); if (regResponse.isRight()) return Either.right(regResponse.right().value()); if (regResponse.left().value().size() > 0) { nodeTemplateInfo.setRequirements(regResponse.left().value()); } } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.CAPABILITIES.getElementName())) { Either>, ResponseFormat> eitherCapRes = createCapModuleFromYaml( nodeTemplateInfo, nodeTemplateJsonMap); if (eitherCapRes.isRight()) return Either.right(eitherCapRes.right().value()); if (eitherCapRes.left().value().size() > 0) { nodeTemplateInfo.setCapabilities(eitherCapRes.left().value()); } } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.PROPERTIES.getElementName())) { Either>, ResponseFormat> regResponse = createPropModuleFromYaml( nodeTemplateJsonMap); if (regResponse.isRight()) return Either.right(regResponse.right().value()); if (regResponse.left().value().size() > 0) { nodeTemplateInfo.setProperties(regResponse.left().value()); } } if (substitutionMappings != null) { if (substitutionMappings.containsKey(ToscaTagNamesEnum.CAPABILITIES.getElementName())) { Either, ResponseFormat> getCapNamesToUpdateRes = getNamesToUpdate( nodeTemplateInfo, (Map>) substitutionMappings .get(ToscaTagNamesEnum.CAPABILITIES.getElementName())); if (getCapNamesToUpdateRes.isRight()) return Either.right(getCapNamesToUpdateRes.right().value()); if (getCapNamesToUpdateRes.left().value().size() > 0) { nodeTemplateInfo.setCapabilitiesNamesToUpdate(getCapNamesToUpdateRes.left().value()); } } if (substitutionMappings.containsKey(ToscaTagNamesEnum.REQUIREMENTS.getElementName())) { Either, ResponseFormat> getReqNamesToUpdateRes = getNamesToUpdate( nodeTemplateInfo, (Map>) substitutionMappings .get(ToscaTagNamesEnum.REQUIREMENTS.getElementName())); if (getReqNamesToUpdateRes.isRight()) return Either.right(getReqNamesToUpdateRes.right().value()); if (getReqNamesToUpdateRes.left().value().size() > 0) { nodeTemplateInfo.setRequirementsNamesToUpdate(getReqNamesToUpdateRes.left().value()); } } } } else { result = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE)); } } catch (Exception e) { BeEcompErrorManager.getInstance().logBeSystemError("Import Resource - create capability"); log.debug("error when creating capability, message:{}", e.getMessage(), e); result = Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML)); } return result; } private Either, ResponseFormat> getNamesToUpdate(UploadComponentInstanceInfo nodeTemplateInfo, Map> elements) { Either, ResponseFormat> response; try { Map namesToUpdate = elements.entrySet().stream() .filter(e -> e.getValue().get(0).equalsIgnoreCase(nodeTemplateInfo.getName())) .collect(Collectors.toMap(e -> e.getValue().get(1), e -> e.getKey())); response = Either.left(namesToUpdate); } catch (Exception e) { log.debug("The exception occurred upon adding names to update for instance {}: ", nodeTemplateInfo.getName(), e); response = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } return response; } @SuppressWarnings("unchecked") private Either>, ResponseFormat> createPropModuleFromYaml( Map nodeTemplateJsonMap) { Map> moduleProp = new HashMap>(); Either>, ResponseFormat> response = Either.left(moduleProp); Either, ResultStatusEnum> toscaProperties = ImportUtils .findFirstToscaMapElement(nodeTemplateJsonMap, ToscaTagNamesEnum.PROPERTIES); if (toscaProperties.isLeft()) { Map jsonProperties = toscaProperties.left().value(); for (Entry jsonPropObj : jsonProperties.entrySet()) { // Property String propName = jsonPropObj.getKey(); Object propValue = jsonPropObj.getValue(); if (valueContainsPattern(STR_REPLACE_PATTERN, propValue)) { log.trace("Ignore property value {}.", propName); continue; } if (valueContainsPattern(TOKEN_PATTERN, propValue)) { log.trace("Ignore property value {}.", propName); continue; } if (valueContainsPattern(GET_PROPERTY_PATTERN, propValue)) { log.trace("Ignore property value {}.", propName); continue; } if (valueContainsPattern(CONCAT_PATTERN, propValue)) { log.trace("Ignore property value {}.", propName); continue; } if (valueContainsPattern(GET_ATTRIBUTE_PATTERN, propValue)) { log.trace("Ignore property value {}.", propName); continue; } UploadPropInfo propertyDef = new UploadPropInfo(); propertyDef.setValue(propValue); propertyDef.setName(propName); if (propValue instanceof Map) { if (((Map) propValue).containsKey(ToscaTagNamesEnum.TYPE.getElementName())) { propertyDef.setType(((Map) propValue) .get(ToscaTagNamesEnum.TYPE.getElementName()).toString()); } if (((Map) propValue).containsKey(ToscaTagNamesEnum.GET_INPUT.getElementName()) || ImportUtils.getPropertyJsonStringValue(propValue, ToscaPropertyType.MAP.getType()) .contains(ToscaTagNamesEnum.GET_INPUT.getElementName())) { createGetInputModuleFromMap(propName, (Map) propValue, propertyDef); } if (((Map) propValue).containsKey(ToscaTagNamesEnum.DESCRIPTION.getElementName())) { propertyDef.setDescription(((Map) propValue) .get(ToscaTagNamesEnum.DESCRIPTION.getElementName()).toString()); } if (((Map) propValue) .containsKey(ToscaTagNamesEnum.DEFAULT_VALUE.getElementName())) { propertyDef.setValue(((Map) propValue) .get(ToscaTagNamesEnum.DEFAULT_VALUE.getElementName())); } if (((Map) propValue).containsKey(ToscaTagNamesEnum.IS_PASSWORD.getElementName())) { propertyDef.setPassword(Boolean.getBoolean(((Map) propValue) .get(ToscaTagNamesEnum.IS_PASSWORD.getElementName()).toString())); } else { propertyDef.setValue(propValue); } } else if (propValue instanceof List) { List propValueList = (List) propValue; createInputPropList(propertyDef, propValueList); propertyDef.setValue(propValue); } if (moduleProp.containsKey(propName)) { moduleProp.get(propName).add(propertyDef); } else { List list = new ArrayList(); list.add(propertyDef); moduleProp.put(propName, list); } } } return response; } @SuppressWarnings("unchecked") private void createInputPropList(UploadPropInfo propertyDef, List propValueList) { for (Object objValue : propValueList) { if (objValue instanceof Map) { Map objMap = (Map) objValue; if (objMap.containsKey(ToscaTagNamesEnum.GET_INPUT.getElementName())) createGetInputModuleFromMap(propertyDef.getName(), objMap, propertyDef); else { Set keys = objMap.keySet(); for (String key : keys) { Object value = objMap.get(key); if (value instanceof Map) { createGetInputModuleFromMap(key, (Map) value, propertyDef); } else if (value instanceof List) { List propSubValueList = (List) value; createInputPropList(propertyDef, propSubValueList); } } } } else if (objValue instanceof List) { List propSubValueList = (List) objValue; createInputPropList(propertyDef, propSubValueList); } } } @SuppressWarnings("unchecked") private void createGetInputModuleFromMap(String propName, Map propValue, UploadPropInfo propertyDef) { if (propValue.containsKey(ToscaTagNamesEnum.GET_INPUT.getElementName())) { Object getInput = propValue.get(ToscaTagNamesEnum.GET_INPUT.getElementName()); GetInputValueDataDefinition getInputInfo = new GetInputValueDataDefinition(); List getInputs = propertyDef.getGet_input(); if (getInputs == null) { getInputs = new ArrayList(); } if (getInput instanceof String) { getInputInfo.setInputName((String) getInput); getInputInfo.setPropName(propName); } else if (getInput instanceof List) { List getInputList = (List) getInput; getInputInfo.setPropName(propName); getInputInfo.setInputName((String) getInputList.get(0)); if (getInputList.size() > 1) { Object indexObj = getInputList.get(1); if (indexObj instanceof Integer) { getInputInfo.setIndexValue((Integer) indexObj); } else if (indexObj instanceof Float) { int index = ((Float) indexObj).intValue(); getInputInfo.setIndexValue(index); } else if (indexObj instanceof Map && ((Map) indexObj) .containsKey(ToscaTagNamesEnum.GET_INPUT.getElementName())) { Object index = ((Map) indexObj) .get(ToscaTagNamesEnum.GET_INPUT.getElementName()); GetInputValueDataDefinition getInputInfoIndex = new GetInputValueDataDefinition(); getInputInfoIndex.setInputName((String) index); getInputInfoIndex.setPropName(propName); getInputInfo.setGetInputIndex(getInputInfoIndex); } getInputInfo.setList(true); } } getInputs.add(getInputInfo); propertyDef.setGet_input(getInputs); propertyDef.setValue(propValue); } else { Set keys = propValue.keySet(); for (String key : keys) { Object value = propValue.get(key); if (value instanceof Map) { createGetInputModuleFromMap(key, (Map) value, propertyDef); } else if (value instanceof List) { List valueList = (List) value; for (Object o : valueList) { if (o instanceof Map) { createGetInputModuleFromMap(key, (Map) o, propertyDef); } } } } } } private boolean valueContainsPattern(Pattern pattern, Object propValue) { log.debug("valueContainsToken value is {}", propValue); boolean result = false; if (propValue != null) { log.trace("valueContainspattern value is {}", propValue.getClass()); Matcher matcher = pattern.matcher(propValue.toString()); result = matcher.find(); } return result; } @SuppressWarnings("unchecked") private Either>, ResponseFormat> createReqModuleFromYaml( UploadComponentInstanceInfo nodeTemplateInfo, Map nodeTemplateJsonMap) { Map> moduleRequirements = new HashMap>(); Either>, ResponseFormat> response = Either.left(moduleRequirements); Either, ResultStatusEnum> requirementsListRes = ImportUtils .findFirstToscaListElement(nodeTemplateJsonMap, ToscaTagNamesEnum.REQUIREMENTS); if (requirementsListRes.isLeft()) { for (Object jsonReqObj : requirementsListRes.left().value()) { String reqName = ((Map) jsonReqObj).keySet().iterator().next(); Object reqJson = ((Map) jsonReqObj).get(reqName); Either eitherCap = addModuleNodeTemplateReq(nodeTemplateInfo, moduleRequirements, reqJson, reqName); if (eitherCap.isRight()) { return Either.right(eitherCap.right().value()); } } } else { Either, ResultStatusEnum> requirementsMapRes = ImportUtils .findFirstToscaMapElement(nodeTemplateJsonMap, ToscaTagNamesEnum.REQUIREMENTS); if (requirementsMapRes.isLeft()) { for (Map.Entry entry : requirementsMapRes.left().value().entrySet()) { String reqName = entry.getKey(); Object reqJson = entry.getValue(); Either eitherCap = addModuleNodeTemplateReq(nodeTemplateInfo, moduleRequirements, reqJson, reqName); if (eitherCap.isRight()) { return Either.right(eitherCap.right().value()); } } } } return response; } private Either addModuleNodeTemplateReq(UploadComponentInstanceInfo nodeTemplateInfo, Map> moduleRequirements, Object requirementJson, String requirementName) { Either eitherRequirement = createModuleNodeTemplateReg(requirementJson); if (eitherRequirement.isRight()) { log.info("error when creating Requirement:{}, for node:{}", requirementName, nodeTemplateInfo); return Either.right(eitherRequirement.right().value()); } else { UploadReqInfo requirementDef = eitherRequirement.left().value(); requirementDef.setName(requirementName); if (moduleRequirements.containsKey(requirementName)) { moduleRequirements.get(requirementName).add(requirementDef); } else { List list = new ArrayList(); list.add(requirementDef); moduleRequirements.put(requirementName, list); } } return Either.left(eitherRequirement.left().value()); } @SuppressWarnings("unchecked") private Either>, ResponseFormat> createCapModuleFromYaml( UploadComponentInstanceInfo nodeTemplateInfo, Map nodeTemplateJsonMap) { Map> moduleCap = new HashMap<>(); Either>, ResponseFormat> response = Either.left(moduleCap); Either, ResultStatusEnum> capabilitiesListRes = ImportUtils .findFirstToscaListElement(nodeTemplateJsonMap, ToscaTagNamesEnum.CAPABILITIES); if (capabilitiesListRes.isLeft()) { for (Object jsonCapObj : capabilitiesListRes.left().value()) { String key = ((Map) jsonCapObj).keySet().iterator().next(); Object capJson = ((Map) jsonCapObj).get(key); Either eitherCap = addModuleNodeTemplateCap(nodeTemplateInfo, moduleCap, capJson, key); if (eitherCap.isRight()) { return Either.right(eitherCap.right().value()); } } } else { Either, ResultStatusEnum> capabilitiesMapRes = ImportUtils .findFirstToscaMapElement(nodeTemplateJsonMap, ToscaTagNamesEnum.CAPABILITIES); if (capabilitiesMapRes.isLeft()) { for (Map.Entry entry : capabilitiesMapRes.left().value().entrySet()) { String capName = entry.getKey(); Object capJson = entry.getValue(); Either eitherCap = addModuleNodeTemplateCap(nodeTemplateInfo, moduleCap, capJson, capName); if (eitherCap.isRight()) { return Either.right(eitherCap.right().value()); } } } } return response; } private Either addModuleNodeTemplateCap(UploadComponentInstanceInfo nodeTemplateInfo, Map> moduleCap, Object capJson, String key) { Either eitherCap = createModuleNodeTemplateCap(capJson); if (eitherCap.isRight()) { log.info("error when creating Capability:{}, for node:{}", key, nodeTemplateInfo); return Either.right(eitherCap.right().value()); } else { UploadCapInfo capabilityDef = eitherCap.left().value(); capabilityDef.setKey(key); if (moduleCap.containsKey(key)) { moduleCap.get(key).add(capabilityDef); } else { List list = new ArrayList(); list.add(capabilityDef); moduleCap.put(key, list); } } return Either.left(eitherCap.left().value()); } @SuppressWarnings("unchecked") private Either createModuleNodeTemplateCap(Object capObject) { UploadCapInfo capTemplateInfo = new UploadCapInfo(); Either result = Either.left(capTemplateInfo); if (capObject instanceof String) { String nodeTemplateJsonString = (String) capObject; capTemplateInfo.setNode(nodeTemplateJsonString); } else if (capObject instanceof Map) { Map nodeTemplateJsonMap = (Map) capObject; // Type if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.NODE.getElementName())) { capTemplateInfo.setNode((String) nodeTemplateJsonMap.get(ToscaTagNamesEnum.NODE.getElementName())); } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.TYPE.getElementName())) { capTemplateInfo.setType((String) nodeTemplateJsonMap.get(ToscaTagNamesEnum.TYPE.getElementName())); } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.VALID_SOURCE_TYPES.getElementName())) { Either, ResultStatusEnum> validSourceTypesRes = ImportUtils .findFirstToscaListElement(nodeTemplateJsonMap, ToscaTagNamesEnum.VALID_SOURCE_TYPES); if (validSourceTypesRes.isLeft()) { capTemplateInfo.setValidSourceTypes(validSourceTypesRes.left().value().stream() .map(o -> o.toString()).collect(Collectors.toList())); } } if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.PROPERTIES.getElementName())) { Either>, ResponseFormat> regResponse = createPropModuleFromYaml( nodeTemplateJsonMap); if (regResponse.isRight()) return Either.right(regResponse.right().value()); if (!regResponse.left().value().isEmpty()) { List properties = new ArrayList(); regResponse.left().value().values().forEach(list -> properties.addAll(list)); if (!properties.isEmpty()) capTemplateInfo.setProperties(properties); } } } return result; } @SuppressWarnings("unchecked") private Either createModuleNodeTemplateReg(Object regObject) { UploadReqInfo regTemplateInfo = new UploadReqInfo(); Either result = Either.left(regTemplateInfo); if (regObject instanceof String) { String nodeTemplateJsonString = (String) regObject; regTemplateInfo.setNode(nodeTemplateJsonString); } else if (regObject instanceof Map) { Map nodeTemplateJsonMap = (Map) regObject; // Type if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.NODE.getElementName())) { regTemplateInfo.setNode((String) nodeTemplateJsonMap.get(ToscaTagNamesEnum.NODE.getElementName())); } // US740820 Relate RIs according to capability name if (nodeTemplateJsonMap.containsKey(ToscaTagNamesEnum.CAPABILITY.getElementName())) { regTemplateInfo.setCapabilityName( (String) nodeTemplateJsonMap.get(ToscaTagNamesEnum.CAPABILITY.getElementName())); } } return result; } public Either propagateStateToCertified(User user, Resource resource, LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock, boolean forceCertificationAllowed) { Either result = null; try { if (resource.getLifecycleState() != LifecycleStateEnum.CERTIFIED && forceCertificationAllowed && lifecycleBusinessLogic.isFirstCertification(resource.getVersion())) { result = nodeForceCertification(resource, user, lifecycleChangeInfo, inTransaction, needLock); if (result.isRight()) { return result; } resource = result.left().value(); } if (resource.getLifecycleState() == LifecycleStateEnum.CERTIFIED) { Either, ResponseFormat> eitherPopulated = populateToscaArtifacts( resource, user, false, inTransaction, needLock); result = eitherPopulated.isLeft() ? Either.left(resource) : Either.right(eitherPopulated.right().value()); return result; } return nodeFullCertification(resource.getUniqueId(), user, lifecycleChangeInfo, inTransaction, needLock); } catch (Exception e) { log.debug("The exception has occurred upon certification of resource {}. ", resource.getName(), e); return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } finally { if (result == null || result.isRight()) { BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify"); if (inTransaction == false) { log.debug("operation failed. do rollback"); titanDao.rollback(); } } else if (inTransaction == false) { log.debug("operation success. do commit"); titanDao.commit(); } } } private Either nodeFullCertification(String uniqueId, User user, LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) { Either result = lifecycleBusinessLogic.changeState(uniqueId, user, LifeCycleTransitionEnum.CERTIFICATION_REQUEST, lifecycleChangeInfo, inTransaction, needLock); if (result.isLeft()) { result = lifecycleBusinessLogic.changeState(uniqueId, user, LifeCycleTransitionEnum.START_CERTIFICATION, lifecycleChangeInfo, inTransaction, needLock); } if (result.isLeft()) { result = lifecycleBusinessLogic.changeState(uniqueId, user, LifeCycleTransitionEnum.CERTIFY, lifecycleChangeInfo, inTransaction, needLock); } return result; } private Either nodeForceCertification(Resource resource, User user, LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) { return lifecycleBusinessLogic.forceResourceCertification(resource, user, lifecycleChangeInfo, inTransaction, needLock); } public Either, ResponseFormat> createOrUpdateResourceByImport( Resource resource, User user, boolean isNormative, boolean isInTransaction, boolean needLock, CsarInfo csarInfo, String nodeName, boolean isNested) { // check if resource already exist Either latestByName = toscaOperationFacade .getLatestByName(resource.getName()); Either, ResponseFormat> result = null; // create if (latestByName.isRight() && latestByName.right().value().equals(StorageOperationStatus.NOT_FOUND)) { Either latestByToscaName = toscaOperationFacade .getLatestByToscaResourceName(resource.getToscaResourceName()); if (csarInfo != null && csarInfo.isUpdate() && nodeName != null && latestByToscaName.isRight() && latestByToscaName.right().value().equals(StorageOperationStatus.NOT_FOUND)) { latestByToscaName = toscaOperationFacade .getLatestByToscaResourceName(buildNestedToscaResourceName(resource.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight()); // update if (latestByToscaName.isLeft()) { log.debug("validate derived before update"); Either eitherValidation = validateNestedDerivedFromDuringUpdate( latestByToscaName.left().value(), resource, ValidationUtils.hasBeenCertified(latestByToscaName.left().value().getVersion())); if (eitherValidation.isRight()) { result = createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo); } else { result = updateExistingResourceByImport(resource, latestByToscaName.left().value(), user, isNormative, needLock, isNested); } } } if (result == null && latestByToscaName.isRight() && latestByToscaName.right().value().equals(StorageOperationStatus.NOT_FOUND)) { result = createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo); } else if (result == null) { StorageOperationStatus status = latestByName.right().value(); BeEcompErrorManager.getInstance().logBeComponentMissingError("Create / Update resource by import", ComponentTypeEnum.RESOURCE.getValue(), resource.getName()); log.debug("resource already exist {}. status={}", resource.getName(), status); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_ALREADY_EXISTS); componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE); result = Either.right(responseFormat); } } // update else if (latestByName.isLeft()) { result = updateExistingResourceByImport(resource, latestByName.left().value(), user, isNormative, needLock, isNested); } // error else { StorageOperationStatus status = latestByName.right().value(); log.debug("failed to get latest version of resource {}. status={}", resource.getName(), status); ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(latestByName.right().value()), resource); componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE); result = Either.right(responseFormat); } return result; } private Either, ResponseFormat> createResourceByImport(Resource resource, User user, boolean isNormative, boolean isInTransaction, CsarInfo csarInfo) { log.debug("resource with name {} does not exist. create new resource", resource.getName()); Either response = validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isInTransaction, csarInfo); if (response.isRight()) { return Either.right(response.right().value()); } Either createResponse = createResourceByDao(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isNormative, isInTransaction); if (createResponse.isRight()) { return Either.right(createResponse.right().value()); } else { ImmutablePair resourcePair = new ImmutablePair<>(createResponse.left().value(), ActionStatus.CREATED); ASDCKpiApi.countImportResourcesKPI(); return Either.left(resourcePair); } } public boolean isResourceExist(String resourceName) { Either latestByName = toscaOperationFacade.getLatestByName(resourceName); return latestByName.isLeft(); } private Either, ResponseFormat> updateExistingResourceByImport( Resource newResource, Resource oldResource, User user, boolean inTransaction, boolean needLock, boolean isNested) { String lockedResourceId = oldResource.getUniqueId(); log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(), oldResource.getLifecycleState()); Either, ResponseFormat> result = null; try { if (needLock) { Either lockResult = lockComponent(lockedResourceId, oldResource, "Update Resource by Import"); if (lockResult.isRight()) { return Either.right(lockResult.right().value()); } } Either prepareResourceForUpdate = prepareResourceForUpdate(oldResource, user, inTransaction, false); if (prepareResourceForUpdate.isRight()) { ResponseFormat responseFormat = prepareResourceForUpdate.right().value(); log.info("resource {} cannot be updated. reason={}", lockedResourceId, responseFormat.getFormattedMessage()); componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE, ResourceAuditData.newBuilder() .state(oldResource.getLifecycleState().name()) .version(oldResource.getVersion()) .build()); result = Either.right(prepareResourceForUpdate.right().value()); return result; } oldResource = prepareResourceForUpdate.left().value(); mergeOldResourceMetadataWithNew(oldResource, newResource); Either validateFieldsResponse = validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested); if (validateFieldsResponse.isRight()) { result = Either.right(validateFieldsResponse.right().value()); return result; } validateFieldsResponse = validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), newResource, AuditingActionEnum.IMPORT_RESOURCE, inTransaction); if (validateFieldsResponse.isRight()) { return Either.right(validateFieldsResponse.right().value()); } // contact info normalization newResource.setContactId(newResource.getContactId().toLowerCase()); // non-updatable fields newResource.setCreatorUserId(user.getUserId()); newResource.setCreatorFullName(user.getFullName()); newResource.setLastUpdaterUserId(user.getUserId()); newResource.setLastUpdaterFullName(user.getFullName()); newResource.setUniqueId(oldResource.getUniqueId()); newResource.setVersion(oldResource.getVersion()); newResource.setInvariantUUID(oldResource.getInvariantUUID()); newResource.setLifecycleState(oldResource.getLifecycleState()); newResource.setUUID(oldResource.getUUID()); newResource.setNormalizedName(oldResource.getNormalizedName()); newResource.setSystemName(oldResource.getSystemName()); if (oldResource.getCsarUUID() != null) { newResource.setCsarUUID(oldResource.getCsarUUID()); } if (oldResource.getImportedToscaChecksum() != null) { newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum()); } newResource.setAbstract(oldResource.isAbstract()); if (newResource.getDerivedFrom() == null || newResource.getDerivedFrom().isEmpty()) { newResource.setDerivedFrom(oldResource.getDerivedFrom()); } if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) { newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType()); } if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) { newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion()); } // TODO rhalili: handle artifacts here (delete from old resource and // add for new) // TODO rbetzer: remove after migration - in case of resources // created without tosca artifacts - add the placeholders if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) { setToscaArtifactsPlaceHolders(newResource, user); } Either overrideResource = toscaOperationFacade .overrideComponent(newResource, oldResource); if (overrideResource.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(overrideResource.right().value()), newResource); componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE); result = Either.right(responseFormat); return result; } log.debug("Resource updated successfully!!!"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK); componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE, ResourceAuditData.newBuilder() .state(oldResource.getLifecycleState().name()).version(oldResource.getVersion()).build()); ImmutablePair resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK); result = Either.left(resourcePair); return result; } finally { if (result == null || result.isRight()) { BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify"); log.debug("operation failed. do rollback"); titanDao.rollback(); } else if (inTransaction == false) { log.debug("operation success. do commit"); titanDao.commit(); } if (needLock == true) { log.debug("unlock resource {}", lockedResourceId); graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource); } } } /** * Merge old resource with new. Keep old category and vendor name without * change * * @param oldResource * @param newResource */ private void mergeOldResourceMetadataWithNew(Resource oldResource, Resource newResource) { // keep old category and vendor name without change // merge the rest of the resource metadata if (newResource.getTags() == null || newResource.getTags().isEmpty()) { newResource.setTags(oldResource.getTags()); } if (newResource.getDescription() == null) { newResource.setDescription(oldResource.getDescription()); } if (newResource.getVendorRelease() == null) { newResource.setVendorRelease(oldResource.getVendorRelease()); } if (newResource.getResourceVendorModelNumber() == null) { newResource.setResourceVendorModelNumber(oldResource.getResourceVendorModelNumber()); } if (newResource.getContactId() == null) { newResource.setContactId(oldResource.getContactId()); } newResource.setCategories(oldResource.getCategories()); if (newResource.getVendorName() == null) { newResource.setVendorName(oldResource.getVendorName()); } } private Either prepareResourceForUpdate(Resource latestResource, User user, boolean inTransaction, boolean needLock) { Either result = Either.left(latestResource); // check if user can edit resource if (!ComponentValidationUtils.canWorkOnResource(latestResource, user.getUserId())) { // checkout Either changeState = lifecycleBusinessLogic.changeState( latestResource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT, new LifecycleChangeInfoWithAction("update by import"), inTransaction, needLock); result = changeState; } return result; } public Either validateResourceBeforeCreate(Resource resource, User user, AuditingActionEnum actionEnum, boolean inTransaction, CsarInfo csarInfo) { Either eitherValidation = validateResourceFieldsBeforeCreate(user, resource, actionEnum, inTransaction); if (eitherValidation.isRight()) { return Either.right(eitherValidation.right().value()); } eitherValidation = validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), resource, actionEnum, inTransaction); if (eitherValidation.isRight()) { return Either.right(eitherValidation.right().value()); } eitherValidation = validateLifecycleTypesCreate(user, resource, actionEnum); if (eitherValidation.isRight()) { return Either.right(eitherValidation.right().value()); } eitherValidation = validateResourceType(user, resource, actionEnum); if (eitherValidation.isRight()) { return Either.right(eitherValidation.right().value()); } resource.setCreatorUserId(user.getUserId()); resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName()); resource.setContactId(resource.getContactId().toLowerCase()); if (StringUtils.isEmpty(resource.getToscaResourceName()) && !ModelConverter.isAtomicComponent(resource)) { String resourceSystemName; if (csarInfo != null && StringUtils.isNotEmpty(csarInfo.getVfResourceName())) { resourceSystemName = ValidationUtils.convertToSystemName(csarInfo.getVfResourceName()); } else { resourceSystemName = resource.getSystemName(); } resource.setToscaResourceName(CommonBeUtils .generateToscaResourceName(resource.getResourceType().name().toLowerCase(), resourceSystemName)); } // Generate invariant UUID - must be here and not in operation since it // should stay constant during clone // TODO String invariantUUID = UniqueIdBuilder.buildInvariantUUID(); resource.setInvariantUUID(invariantUUID); return Either.left(resource); } private Either validateResourceType(User user, Resource resource, AuditingActionEnum actionEnum) { Either eitherResult = Either.left(true); if (resource.getResourceType() == null) { log.debug("Invalid resource type for resource"); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); eitherResult = Either.right(errorResponse); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); } return eitherResult; } private Either validateLifecycleTypesCreate(User user, Resource resource, AuditingActionEnum actionEnum) { Either eitherResult = Either.left(true); if (resource.getInterfaces() != null && resource.getInterfaces().size() > 0) { log.debug("validate interface lifecycle Types Exist"); Iterator intItr = resource.getInterfaces().values().iterator(); while (intItr.hasNext() && eitherResult.isLeft()) { InterfaceDefinition interfaceDefinition = intItr.next(); String intType = interfaceDefinition.getUniqueId(); Either eitherCapTypeFound = interfaceTypeOperation .getInterface(intType); if (eitherCapTypeFound.isRight()) { if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logBeGraphObjectMissingError( "Create Resource - validateLifecycleTypesCreate", "Interface", intType); log.debug("Lifecycle Type: {} is required by resource: {} but does not exist in the DB", intType, resource.getName()); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Create Resource - validateLifecycleTypesCreate"); log.debug("request to data model failed with error: {}", eitherCapTypeFound.right().value().name()); } ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.MISSING_LIFECYCLE_TYPE, intType); eitherResult = Either.right(errorResponse); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); } } } return eitherResult; } private Either validateCapabilityTypesCreate(User user, ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) { Either eitherResult = Either.left(true); if (resource.getCapabilities() != null && resource.getCapabilities().size() > 0) { log.debug("validate capability Types Exist - capabilities section"); for (Entry> typeEntry : resource.getCapabilities().entrySet()) { eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource, actionEnum, eitherResult, typeEntry, inTransaction); if (eitherResult.isRight()) { return Either.right(eitherResult.right().value()); } } } if (resource.getRequirements() != null && resource.getRequirements().size() > 0) { log.debug("validate capability Types Exist - requirements section"); for (String type : resource.getRequirements().keySet()) { eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource, resource.getRequirements().get(type), actionEnum, eitherResult, type, inTransaction); if (eitherResult.isRight()) { return Either.right(eitherResult.right().value()); } } } return eitherResult; } // @param typeObject- the object to which the validation is done private Either validateCapabilityTypeExists(User user, ICapabilityTypeOperation capabilityTypeOperation, Resource resource, List validationObjects, AuditingActionEnum actionEnum, Either eitherResult, String type, boolean inTransaction) { Either eitherCapTypeFound = capabilityTypeOperation .getCapabilityType(type, inTransaction); if (eitherCapTypeFound.isRight()) { if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logBeGraphObjectMissingError( "Create Resource - validateCapabilityTypesCreate", "Capability Type", type); log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB", type, resource.getName()); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Create Resource - validateCapabilityTypesCreate"); } log.debug("Trying to get capability type {} failed with error: {}", type, eitherCapTypeFound.right().value().name()); ResponseFormat errorResponse = null; if (type != null) errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, type); else errorResponse = componentsUtils.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE, validationObjects); eitherResult = Either.right(errorResponse); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); } return eitherResult; } private Either validateCapabilityTypeExists(User user, ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum, Either eitherResult, Entry> typeEntry, boolean inTransaction) { Either eitherCapTypeFound = capabilityTypeOperation .getCapabilityType(typeEntry.getKey(), inTransaction); if (eitherCapTypeFound.isRight()) { if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logBeGraphObjectMissingError( "Create Resource - validateCapabilityTypesCreate", "Capability Type", typeEntry.getKey()); log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB", typeEntry.getKey(), resource.getName()); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Create Resource - validateCapabilityTypesCreate"); } log.debug("Trying to get capability type {} failed with error: {}", typeEntry.getKey(), eitherCapTypeFound.right().value().name()); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, typeEntry.getKey()); eitherResult = Either.right(errorResponse); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); } CapabilityTypeDefinition capabilityTypeDefinition = eitherCapTypeFound.left().value(); if (capabilityTypeDefinition.getProperties() != null) { for (CapabilityDefinition capDef : typeEntry.getValue()) { List properties = capDef.getProperties(); if (properties == null || properties.isEmpty()) { properties = new ArrayList(); for (Entry prop : capabilityTypeDefinition.getProperties().entrySet()) { ComponentInstanceProperty newProp = new ComponentInstanceProperty(prop.getValue()); properties.add(newProp); } } else { for (Entry prop : capabilityTypeDefinition.getProperties().entrySet()) { PropertyDefinition porpFromDef = prop.getValue(); List propsToAdd = new ArrayList<>(); for (ComponentInstanceProperty cip : properties) { if (!cip.getName().equals(porpFromDef.getName())) { ComponentInstanceProperty newProp = new ComponentInstanceProperty(porpFromDef); propsToAdd.add(newProp); } } if (!propsToAdd.isEmpty()) { properties.addAll(propsToAdd); } } } capDef.setProperties(properties); } } return eitherResult; } public Either createResourceByDao(Resource resource, User user, AuditingActionEnum actionEnum, boolean isNormative, boolean inTransaction) { // create resource // lock new resource name in order to avoid creation resource with same // name if (inTransaction == false) { Either lockResult = lockComponentByName(resource.getSystemName(), resource, "Create Resource"); if (lockResult.isRight()) { ResponseFormat responseFormat = lockResult.right().value(); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult); } try { if (resource.deriveFromGeneric()) { Either genericResourceEither = handleResourceGenericType(resource); if (genericResourceEither.isRight()) return genericResourceEither; } Either respStatus = createResourceTransaction(resource, user, isNormative, inTransaction); if (respStatus.isLeft()) { componentsUtils.auditResource(componentsUtils.getResponseFormat(ActionStatus.CREATED), user, respStatus.left().value(), actionEnum); ASDCKpiApi.countCreatedResourcesKPI(); } else componentsUtils.auditResource(respStatus.right().value(), user, resource, actionEnum); return respStatus; } finally { if (inTransaction == false) { graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource); } } } private Either createResourceTransaction(Resource resource, User user, boolean isNormative, boolean inTransaction) { // validate resource name uniqueness log.debug("validate resource name"); Either eitherValidation = toscaOperationFacade.validateComponentNameExists( resource.getName(), resource.getResourceType(), resource.getComponentType()); if (eitherValidation.isRight()) { log.debug("Failed to validate component name {}. Status is {}. ", resource.getName(), eitherValidation.right().value()); ResponseFormat errorResponse = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value())); return Either.right(errorResponse); } if (eitherValidation.left().value()) { log.debug("resource with name: {}, already exists", resource.getName()); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName()); return Either.right(errorResponse); } log.debug("send resource {} to dao for create", resource.getName()); createArtifactsPlaceHolderData(resource, user); // // enrich object if (!isNormative) { log.debug("enrich resource with creator, version and state"); resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); resource.setVersion(INITIAL_VERSION); resource.setHighestVersion(true); if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.CVFC) resource.setAbstract(false); } Either createToscaElement = toscaOperationFacade .createToscaComponent(resource); if (createToscaElement.isLeft()) { return Either.left(createToscaElement.left().value()); } ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(createToscaElement.right().value()), resource); return Either.right(responseFormat); } private void createArtifactsPlaceHolderData(Resource resource, User user) { // create mandatory artifacts // TODO it must be removed after that artifact uniqueId creation will be // moved to ArtifactOperation setInformationalArtifactsPlaceHolder(resource, user); setDeploymentArtifactsPlaceHolder(resource, user); setToscaArtifactsPlaceHolders(resource, user); } @SuppressWarnings("unchecked") @Override public void setDeploymentArtifactsPlaceHolder(Component component, User user) { Resource resource = (Resource) component; Map artifactMap = resource.getDeploymentArtifacts(); if (artifactMap == null) { artifactMap = new HashMap(); } Map deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager() .getConfiguration().getDeploymentResourceArtifacts(); if (deploymentResourceArtifacts != null) { Iterator> iterator = deploymentResourceArtifacts.entrySet().iterator(); while (iterator.hasNext()) { Entry currEntry = iterator.next(); boolean shouldCreateArtifact = true; Map artifactDetails = (Map) currEntry.getValue(); Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES); if (object != null) { List artifactTypes = (List) object; if (!artifactTypes.contains(resource.getResourceType().name())) { shouldCreateArtifact = false; continue; } } else { log.info("resource types for artifact placeholder {} were not defined. default is all resources", currEntry.getKey()); } if (shouldCreateArtifact) { if (artifactsBusinessLogic != null) { ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo( resource.getUniqueId(), currEntry.getKey(), (Map) currEntry.getValue(), user, ArtifactGroupTypeEnum.DEPLOYMENT); if (artifactDefinition != null && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition); } } } } resource.setDeploymentArtifacts(artifactMap); } @SuppressWarnings("unchecked") private void setInformationalArtifactsPlaceHolder(Resource resource, User user) { Map artifactMap = resource.getArtifacts(); if (artifactMap == null) { artifactMap = new HashMap(); } String resourceUniqueId = resource.getUniqueId(); List exludeResourceCategory = ConfigurationManager.getConfigurationManager().getConfiguration() .getExcludeResourceCategory(); List exludeResourceType = ConfigurationManager.getConfigurationManager().getConfiguration() .getExcludeResourceType(); Map informationalResourceArtifacts = ConfigurationManager.getConfigurationManager() .getConfiguration().getInformationalResourceArtifacts(); List categories = resource.getCategories(); boolean isCreateArtifact = true; if (exludeResourceCategory != null) { String category = categories.get(0).getName(); for (String exlude : exludeResourceCategory) { if (exlude.equalsIgnoreCase(category)) { isCreateArtifact = false; break; } } } if (isCreateArtifact && exludeResourceType != null) { String resourceType = resource.getResourceType().name(); for (String type : exludeResourceType) { if (type.equalsIgnoreCase(resourceType)) { isCreateArtifact = false; break; } } } if (informationalResourceArtifacts != null && isCreateArtifact) { Set keys = informationalResourceArtifacts.keySet(); for (String informationalResourceArtifactName : keys) { Map artifactInfoMap = (Map) informationalResourceArtifacts .get(informationalResourceArtifactName); ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo( resourceUniqueId, informationalResourceArtifactName, artifactInfoMap, user, ArtifactGroupTypeEnum.INFORMATIONAL); artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition); } } resource.setArtifacts(artifactMap); } /** * deleteResource * * @param resourceId * @param user * @return */ public ResponseFormat deleteResource(String resourceId, User user) { ResponseFormat responseFormat; Either eitherCreator = validateUserExists(user, "Delete Resource", false); if (eitherCreator.isRight()) { return eitherCreator.right().value(); } Either resourceStatus = toscaOperationFacade.getToscaElement(resourceId); if (resourceStatus.isRight()) { log.debug("failed to get resource {}", resourceId); return componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceStatus.right().value()), ""); } Resource resource = resourceStatus.left().value(); StorageOperationStatus result = StorageOperationStatus.OK; Either lockResult = lockComponent(resourceId, resource, "Mark resource to delete"); if (lockResult.isRight()) { result = StorageOperationStatus.GENERAL_ERROR; return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); } try { result = markComponentToDelete(resource); if (result.equals(StorageOperationStatus.OK)) { responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT); } else { ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result); responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName()); } return responseFormat; } finally { if (result == null || !result.equals(StorageOperationStatus.OK)) { log.warn("operation failed. do rollback"); titanDao.rollback(); } else { log.debug("operation success. do commit"); titanDao.commit(); } graphLockOperation.unlockComponent(resourceId, NodeTypeEnum.Resource); } } public ResponseFormat deleteResourceByNameAndVersion(String resourceName, String version, User user) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT); Either eitherCreator = validateUserExists(user, "Delete Resource", false); if (eitherCreator.isRight()) { return eitherCreator.right().value(); } Resource resource = null; StorageOperationStatus result = StorageOperationStatus.OK; try { Either resourceStatus = toscaOperationFacade .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, version); if (resourceStatus.isRight()) { log.debug("failed to get resource {} version {}", resourceName, version); return componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(resourceStatus.right().value()), resourceName); } resource = resourceStatus.left().value(); } finally { if (result == null || !result.equals(StorageOperationStatus.OK)) { log.warn("operation failed. do rollback"); titanDao.rollback(); ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result); responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resourceName); } else { log.debug("operation success. do commit"); titanDao.commit(); } } if (resource != null) { Either lockResult = lockComponent(resource.getUniqueId(), resource, "Delete Resource"); if (lockResult.isRight()) { result = StorageOperationStatus.GENERAL_ERROR; return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); } try { result = markComponentToDelete(resource); if (!result.equals(StorageOperationStatus.OK)) { ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result); responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName()); return responseFormat; } } finally { if (result == null || !result.equals(StorageOperationStatus.OK)) { log.warn("operation failed. do rollback"); titanDao.rollback(); } else { log.debug("operation success. do commit"); titanDao.commit(); } graphLockOperation.unlockComponent(resource.getUniqueId(), NodeTypeEnum.Resource); } } return responseFormat; } public Either getResource(String resourceId, User user) { if (user != null) { Either eitherCreator = validateUserExists(user, "Create Resource", false); if (eitherCreator.isRight()) { return Either.right(eitherCreator.right().value()); } } Either storageStatus = toscaOperationFacade.getToscaElement(resourceId); if (storageStatus.isRight()) { log.debug("failed to get resource by id {}", resourceId); return Either.right(componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(storageStatus.right().value()), resourceId)); } if (!(storageStatus.left().value() instanceof Resource)) { return Either.right(componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), resourceId)); } return Either.left(storageStatus.left().value()); } public Either getResourceByNameAndVersion(String resourceName, String resourceVersion, String userId) { Either resp = validateUserExists(userId, "get Resource By Name And Version", false); if (resp.isRight()) { return Either.right(resp.right().value()); } Either getResource = toscaOperationFacade .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion); if (getResource.isRight()) { log.debug("failed to get resource by name {} and version {}", resourceName, resourceVersion); return Either.right(componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(getResource.right().value()), resourceName)); } return Either.left(getResource.left().value()); } /** * updateResourceMetadata * * @param user - modifier data (userId) * @param inTransaction TODO * @param resourceIdToUpdate - the resource identifier * @param newResource * @return Either */ public Either updateResourceMetadata(String resourceIdToUpdate, Resource newResource, Resource currentResource, User user, boolean inTransaction) { Either resp = validateUserExists(user.getUserId(), "update Resource Metadata", false); if (resp.isRight()) { return Either.right(resp.right().value()); } log.debug("Get resource with id {}", resourceIdToUpdate); boolean needToUnlock = false; boolean rollbackNeeded = true; try { if (currentResource == null) { Either storageStatus = toscaOperationFacade .getToscaElement(resourceIdToUpdate); if (storageStatus.isRight()) { return Either.right(componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(storageStatus.right().value()), "")); } currentResource = storageStatus.left().value(); } // verify that resource is checked-out and the user is the last // updater if (!ComponentValidationUtils.canWorkOnResource(currentResource, user.getUserId())) { return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)); } // lock resource StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceIdToUpdate, NodeTypeEnum.Resource); if (!lockResult.equals(StorageOperationStatus.OK)) { BeEcompErrorManager.getInstance().logBeFailedLockObjectError("Upload Artifact - lock ", NodeTypeEnum.Resource.getName(), resourceIdToUpdate); log.debug("Failed to lock resource: {}, error - {}", resourceIdToUpdate, lockResult); ResponseFormat responseFormat = componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(lockResult)); return Either.right(responseFormat); } needToUnlock = true; // critical section starts here // convert json to object // Update and updated resource must have a non-empty "derivedFrom" // list // This code is not called from import resources, because of root // VF "derivedFrom" should be null (or ignored) if (ModelConverter.isAtomicComponent(currentResource)) { Either derivedFromNotEmptyEither = validateDerivedFromNotEmpty(null, newResource, null); if (derivedFromNotEmptyEither.isRight()) { log.debug("for updated resource {}, derived from field is empty", newResource.getName()); return Either.right(derivedFromNotEmptyEither.right().value()); } derivedFromNotEmptyEither = validateDerivedFromNotEmpty(null, currentResource, null); if (derivedFromNotEmptyEither.isRight()) { log.debug("for current resource {}, derived from field is empty", currentResource.getName()); return Either.right(derivedFromNotEmptyEither.right().value()); } } else { newResource.setDerivedFrom(null); } Either validateAndUpdateInterfacesEither = validateAndUpdateInterfaces(resourceIdToUpdate, newResource); if (validateAndUpdateInterfacesEither.isRight()) { log.error("failed to validate and update Interfaces !!!"); rollbackNeeded = true; return Either.right(validateAndUpdateInterfacesEither.right().value()); } Either dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource, user, currentResource, false, true); if (dataModelResponse.isRight()) { log.debug("failed to update resource metadata!!!"); rollbackNeeded = true; return Either.right(dataModelResponse.right().value()); } log.debug("Resource metadata updated successfully!!!"); rollbackNeeded = false; return Either.left(dataModelResponse.left().value()); } finally { if (!inTransaction) { if (rollbackNeeded) { titanDao.rollback(); } else { titanDao.commit(); } } if (needToUnlock) { graphLockOperation.unlockComponent(resourceIdToUpdate, NodeTypeEnum.Resource); } } } private Either, Boolean> updateComponentGroupName(String replacePattern, String with, List oldGroup) { if (oldGroup == null || with == null || replacePattern == null || with.isEmpty() || replacePattern.isEmpty()) { if (log.isInfoEnabled()) log.info("cannot update group name , invalid args -> replacePattern:{} , with:{} , oldGroup:{}", replacePattern, with, oldGroup == null ? null : " < size : " + oldGroup.size() + " >"); return Either.right(false); } List list = oldGroup.stream().map(group -> new GroupDefinition(group)) .collect(Collectors.toList()); for (GroupDefinition group : list) { if (group != null && group.isSamePrefix(replacePattern)) { String prefix = group.getName().substring(0, replacePattern.length()); String newGroupName = group.getName().replaceFirst(prefix, with); group.setName(newGroupName); } } return Either.left(list); } private boolean isComponentNameChanged(Resource newResource, Resource oldResource) { if (newResource != null && oldResource != null) { // TODO - must protect // all chain against // null , use // optional String futureName = newResource.getComponentMetadataDefinition().getMetadataDataDefinition().getName(); String oldName = oldResource.getComponentMetadataDefinition().getMetadataDataDefinition().getName(); return !oldName.equals(futureName); } return false; } private Either updateResourceMetadata(String resourceIdToUpdate, Resource newResource, User user, Resource currentResource, boolean shouldLock, boolean inTransaction) { // region -> Update groups name for newResource if (isComponentNameChanged(currentResource, newResource)) { String replacePattern = Optional.ofNullable( // get currentResource // name from // metadata Optional.ofNullable( Optional.ofNullable(currentResource).orElse(null).getComponentMetadataDefinition()) .orElse(null).getMetadataDataDefinition()) .orElse(null).getName(); String with = Optional.ofNullable( // get newResource name from // metadata Optional.ofNullable(Optional.ofNullable(newResource).orElse(null).getComponentMetadataDefinition()) .orElse(null).getMetadataDataDefinition()) .orElse(null).getName(); if (with != null && replacePattern != null) { Either, Boolean> result = updateComponentGroupName(replacePattern, with, currentResource.getGroups()); if (result.isLeft()) newResource.setGroups((List) result.left().value()); } } // endregion Either validateResourceFields = validateResourceFieldsBeforeUpdate(currentResource, newResource, inTransaction, false); if (validateResourceFields.isRight()) { return Either.right(validateResourceFields.right().value()); } // Setting last updater and uniqueId newResource.setContactId(newResource.getContactId().toLowerCase()); newResource.setLastUpdaterUserId(user.getUserId()); newResource.setUniqueId(resourceIdToUpdate); // Cannot set highest version through UI newResource.setHighestVersion(currentResource.isHighestVersion()); newResource.setCreationDate(currentResource.getCreationDate()); Either processUpdateOfDerivedFrom = processUpdateOfDerivedFrom(currentResource, newResource, user.getUserId(), shouldLock, inTransaction); if (processUpdateOfDerivedFrom.isRight()) { log.debug("Couldn't update derived from for resource {}", resourceIdToUpdate); return Either.right(processUpdateOfDerivedFrom.right().value()); } log.debug("send resource {} to dao for update", newResource.getUniqueId()); if (newResource != null && newResource.getGroups() != null) { for (GroupDefinition group : newResource.getGroups()) { if (newResource.getComponentMetadataDefinition() != null && newResource.getComponentMetadataDefinition().getMetadataDataDefinition() != null) groupBusinessLogic.validateAndUpdateGroupMetadata( newResource.getComponentMetadataDefinition().getMetadataDataDefinition().getUniqueId(), user, ComponentTypeEnum.RESOURCE_INSTANCE, group, true, false); } } Either dataModelResponse = toscaOperationFacade .updateToscaElement(newResource); if (dataModelResponse.isRight()) { ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()), newResource); return Either.right(responseFormat); } else if (dataModelResponse.left().value() == null) { log.debug("No response from updateResource"); return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } return Either.left(dataModelResponse.left().value()); } /** * validateResourceFieldsBeforeCreate * * @param user - modifier data (userId) * @return Either */ private Either validateResourceFieldsBeforeCreate(User user, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) { Either componentsFieldsValidation = validateComponentFieldsBeforeCreate(user, resource, actionEnum); if (componentsFieldsValidation.isRight()) { return componentsFieldsValidation; } // validate category log.debug("validate category"); Either eitherValidation = validateCategory(user, resource, actionEnum, inTransaction); if (eitherValidation.isRight()) { return eitherValidation; } // validate vendor name & release & model number log.debug("validate vendor name"); eitherValidation = validateVendorName(user, resource, actionEnum); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate vendor release"); eitherValidation = validateVendorReleaseName(user, resource, actionEnum); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate resource vendor model number"); eitherValidation = validateResourceVendorModelNumber(user, resource, actionEnum); if (eitherValidation.isRight()) { return eitherValidation; } // validate cost log.debug("validate cost"); eitherValidation = validateCost(user, resource, actionEnum); if (eitherValidation.isRight()) { return eitherValidation; } // validate licenseType log.debug("validate licenseType"); eitherValidation = validateLicenseType(user, resource, actionEnum); if (eitherValidation.isRight()) { return eitherValidation; } // validate template (derived from) log.debug("validate derived from"); if (!ModelConverter.isAtomicComponent(resource) && resource.getResourceType() != ResourceTypeEnum.CVFC) { resource.setDerivedFrom(null); } eitherValidation = validateDerivedFromExist(user, resource, actionEnum); if (eitherValidation.isRight()) { return Either.right(eitherValidation.right().value()); } // warn about non-updatable fields checkComponentFieldsForOverrideAttempt(resource); String currentCreatorFullName = resource.getCreatorFullName(); if (currentCreatorFullName != null) { log.warn("Resource Creator fullname is automatically set and cannot be updated"); } String currentLastUpdaterFullName = resource.getLastUpdaterFullName(); if (currentLastUpdaterFullName != null) { log.warn("Resource LastUpdater fullname is automatically set and cannot be updated"); } Long currentLastUpdateDate = resource.getLastUpdateDate(); if (currentLastUpdateDate != null) { log.warn("Resource last update date is automatically set and cannot be updated"); } Boolean currentAbstract = resource.isAbstract(); if (currentAbstract != null) { log.warn("Resource abstract is automatically set and cannot be updated"); } return Either.left(true); } /** * validateResourceFieldsBeforeUpdate * * @param currentResource - Resource object to validate * @param isNested * @return Either */ private Either validateResourceFieldsBeforeUpdate(Resource currentResource, Resource updateInfoResource, boolean inTransaction, boolean isNested) { boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentResource.getVersion()); // validate resource name log.debug("validate resource name before update"); Either eitherValidation = validateResourceName(currentResource, updateInfoResource, hasBeenCertified, isNested); if (eitherValidation.isRight()) { return eitherValidation; } // validate description log.debug("validate description before update"); eitherValidation = validateDescriptionAndCleanup(null, updateInfoResource, null); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate icon before update"); eitherValidation = validateIcon(currentResource, updateInfoResource, hasBeenCertified); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate tags before update"); eitherValidation = validateTagsListAndRemoveDuplicates(null, updateInfoResource, null); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate vendor name before update"); eitherValidation = validateVendorName(currentResource, updateInfoResource, hasBeenCertified); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate resource vendor model number before update"); eitherValidation = validateResourceVendorModelNumber(currentResource, updateInfoResource); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate vendor release before update"); eitherValidation = validateVendorReleaseName(null, updateInfoResource, null); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate contact info before update"); eitherValidation = validateContactId(null, updateInfoResource, null); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate derived before update"); eitherValidation = validateDerivedFromDuringUpdate(currentResource, updateInfoResource, hasBeenCertified); if (eitherValidation.isRight()) { return eitherValidation; } log.debug("validate category before update"); eitherValidation = validateCategory(currentResource, updateInfoResource, hasBeenCertified, inTransaction); if (eitherValidation.isRight()) { return eitherValidation; } // warn about non-updatable fields String currentResourceVersion = currentResource.getVersion(); String updatedResourceVersion = updateInfoResource.getVersion(); if ((updatedResourceVersion != null) && (!updatedResourceVersion.equals(currentResourceVersion))) { log.warn("Resource version is automatically set and cannot be updated"); } String currentCreatorUserId = currentResource.getCreatorUserId(); String updatedCreatorUserId = updateInfoResource.getCreatorUserId(); if ((updatedCreatorUserId != null) && (!updatedCreatorUserId.equals(currentCreatorUserId))) { log.warn("Resource Creator UserId is automatically set and cannot be updated"); } String currentCreatorFullName = currentResource.getCreatorFullName(); String updatedCreatorFullName = updateInfoResource.getCreatorFullName(); if ((updatedCreatorFullName != null) && (!updatedCreatorFullName.equals(currentCreatorFullName))) { log.warn("Resource Creator fullname is automatically set and cannot be updated"); } String currentLastUpdaterUserId = currentResource.getLastUpdaterUserId(); String updatedLastUpdaterUserId = updateInfoResource.getLastUpdaterUserId(); if ((updatedLastUpdaterUserId != null) && (!updatedLastUpdaterUserId.equals(currentLastUpdaterUserId))) { log.warn("Resource LastUpdater userId is automatically set and cannot be updated"); } String currentLastUpdaterFullName = currentResource.getLastUpdaterFullName(); String updatedLastUpdaterFullName = updateInfoResource.getLastUpdaterFullName(); if ((updatedLastUpdaterFullName != null) && (!updatedLastUpdaterFullName.equals(currentLastUpdaterFullName))) { log.warn("Resource LastUpdater fullname is automatically set and cannot be updated"); } Long currentCreationDate = currentResource.getCreationDate(); Long updatedCreationDate = updateInfoResource.getCreationDate(); if ((updatedCreationDate != null) && (!updatedCreationDate.equals(currentCreationDate))) { log.warn("Resource Creation date is automatically set and cannot be updated"); } Long currentLastUpdateDate = currentResource.getLastUpdateDate(); Long updatedLastUpdateDate = updateInfoResource.getLastUpdateDate(); if ((updatedLastUpdateDate != null) && (!updatedLastUpdateDate.equals(currentLastUpdateDate))) { log.warn("Resource last update date is automatically set and cannot be updated"); } LifecycleStateEnum currentLifecycleState = currentResource.getLifecycleState(); LifecycleStateEnum updatedLifecycleState = updateInfoResource.getLifecycleState(); if ((updatedLifecycleState != null) && (!updatedLifecycleState.equals(currentLifecycleState))) { log.warn("Resource lifecycle state date is automatically set and cannot be updated"); } Boolean currentAbstract = currentResource.isAbstract(); Boolean updatedAbstract = updateInfoResource.isAbstract(); if ((updatedAbstract != null) && (!updatedAbstract.equals(currentAbstract))) { log.warn("Resource abstract is automatically set and cannot be updated"); } Boolean currentHighestVersion = currentResource.isHighestVersion(); Boolean updatedHighestVersion = updateInfoResource.isHighestVersion(); if ((updatedHighestVersion != null) && (!updatedHighestVersion.equals(currentHighestVersion))) { log.warn("Resource highest version is automatically set and cannot be updated"); } String currentUuid = currentResource.getUUID(); String updatedUuid = updateInfoResource.getUUID(); if ((updatedUuid != null) && (!updatedUuid.equals(currentUuid))) { log.warn("Resource UUID is automatically set and cannot be updated"); } ResourceTypeEnum currentResourceType = currentResource.getResourceType(); ResourceTypeEnum updatedResourceType = updateInfoResource.getResourceType(); if ((updatedResourceType != null) && (!updatedResourceType.equals(currentResourceType))) { log.warn("Resource Type cannot be updated"); } updateInfoResource.setResourceType(currentResource.getResourceType()); String currentInvariantUuid = currentResource.getInvariantUUID(); String updatedInvariantUuid = updateInfoResource.getInvariantUUID(); if ((updatedInvariantUuid != null) && (!updatedInvariantUuid.equals(currentInvariantUuid))) { log.warn("Resource invariant UUID is automatically set and cannot be updated"); updateInfoResource.setInvariantUUID(currentInvariantUuid); } return Either.left(true); } private boolean isResourceNameEquals(Resource currentResource, Resource updateInfoResource) { String resourceNameUpdated = updateInfoResource.getName(); String resourceNameCurrent = currentResource.getName(); if (resourceNameCurrent.equals(resourceNameUpdated)) return true; // In case of CVFC type we should support the case of old VF with CVFC // instances that were created without the "Cvfc" suffix return currentResource.getResourceType().equals(ResourceTypeEnum.CVFC) && resourceNameUpdated.equals(addCvfcSuffixToResourceName(resourceNameCurrent)); } private String addCvfcSuffixToResourceName(String resourceName) { return resourceName + "Cvfc"; } private Either validateResourceName(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified, boolean isNested) { String resourceNameUpdated = updateInfoResource.getName(); if (!isResourceNameEquals(currentResource, updateInfoResource)) { if (isNested || !hasBeenCertified) { Either validateResourceNameResponse = validateComponentName(null, updateInfoResource, null); if (validateResourceNameResponse.isRight()) { ResponseFormat errorResponse = validateResourceNameResponse.right().value(); return Either.right(errorResponse); } validateResourceNameResponse = validateResourceNameExists(updateInfoResource); if (validateResourceNameResponse.isRight()) { ResponseFormat errorResponse = validateResourceNameResponse.right().value(); return Either.right(errorResponse); } currentResource.setName(resourceNameUpdated); currentResource.setNormalizedName(ValidationUtils.normaliseComponentName(resourceNameUpdated)); currentResource.setSystemName(ValidationUtils.convertToSystemName(resourceNameUpdated)); } else { log.info("Resource name: {}, cannot be updated once the resource has been certified once.", resourceNameUpdated); ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED); return Either.right(errorResponse); } } return Either.left(true); } private Either validateIcon(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) { String iconUpdated = updateInfoResource.getIcon(); String iconCurrent = currentResource.getIcon(); if (!iconCurrent.equals(iconUpdated)) { if (!hasBeenCertified) { Either validateIcon = validateIcon(null, updateInfoResource, null); if (validateIcon.isRight()) { ResponseFormat errorResponse = validateIcon.right().value(); return Either.right(errorResponse); } } else { log.info("Icon {} cannot be updated once the resource has been certified once.", iconUpdated); ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED); return Either.right(errorResponse); } } return Either.left(true); } private Either validateVendorName(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) { String vendorNameUpdated = updateInfoResource.getVendorName(); String vendorNameCurrent = currentResource.getVendorName(); if (!vendorNameCurrent.equals(vendorNameUpdated)) { if(updateInfoResource.getResourceType().equals(ResourceTypeEnum.VF) && hasBeenCertified ){ log.info("Vendor name {} cannot be updated once the resource has been certified once.", vendorNameUpdated); ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.RESOURCE_VENDOR_NAME_CANNOT_BE_CHANGED); return Either.right(errorResponse); } else { Either validateVendorName = validateVendorName(null, updateInfoResource, null); if (validateVendorName.isRight()) { ResponseFormat errorResponse = validateVendorName.right().value(); return Either.right(errorResponse); } } } return Either.left(true); } private Either validateResourceVendorModelNumber(Resource currentResource, Resource updateInfoResource) { String updatedResourceVendorModelNumber = updateInfoResource.getResourceVendorModelNumber(); String currentResourceVendorModelNumber = currentResource.getResourceVendorModelNumber(); if (!currentResourceVendorModelNumber.equals(updatedResourceVendorModelNumber)) { Either validateResourceVendorModelNumber = validateResourceVendorModelNumber(null, updateInfoResource, null); if (validateResourceVendorModelNumber.isRight()) { ResponseFormat errorResponse = validateResourceVendorModelNumber.right().value(); return Either.right(errorResponse); } } return Either.left(true); } private Either validateCategory(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified, boolean inTransaction) { Either validateCategoryName = validateCategory(null, updateInfoResource, null, inTransaction); if (validateCategoryName.isRight()) { ResponseFormat errorResponse = validateCategoryName.right().value(); return Either.right(errorResponse); } if (hasBeenCertified) { CategoryDefinition currentCategory = currentResource.getCategories().get(0); SubCategoryDefinition currentSubCategory = currentCategory.getSubcategories().get(0); CategoryDefinition updateCategory = updateInfoResource.getCategories().get(0); SubCategoryDefinition updtaeSubCategory = updateCategory.getSubcategories().get(0); if (!currentCategory.getName().equals(updateCategory.getName()) || !currentSubCategory.getName().equals(updtaeSubCategory.getName())) { log.info("Category {} cannot be updated once the resource has been certified once.", currentResource.getCategories()); ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED); return Either.right(errorResponse); } } return Either.left(true); } private Either validateDerivedFromDuringUpdate(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) { List currentDerivedFrom = currentResource.getDerivedFrom(); List updatedDerivedFrom = updateInfoResource.getDerivedFrom(); if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null || updatedDerivedFrom.isEmpty()) { log.trace("Update normative types"); return Either.left(true); } String derivedFromCurrent = currentDerivedFrom.get(0); String derivedFromUpdated = updatedDerivedFrom.get(0); if (!derivedFromCurrent.equals(derivedFromUpdated)) { if (!hasBeenCertified) { Either validateDerivedFromExistsEither = validateDerivedFromExist(null, updateInfoResource, null); if (validateDerivedFromExistsEither.isRight()) { return validateDerivedFromExistsEither; } } else { Either validateDerivedFromExtending = validateDerivedFromExtending(null, currentResource, updateInfoResource, null); if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left().value()) { log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance"); return validateDerivedFromExtending; } } } else { // For derived from, we must know whether it was actually changed, // otherwise we must do no action. // Due to changes it inflicts on data model (remove artifacts, // properties...), it's not like a flat field which can be // overwritten if not changed. // So we must indicate that derived from is not changed updateInfoResource.setDerivedFrom(null); } return Either.left(true); } private Either validateNestedDerivedFromDuringUpdate(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) { List currentDerivedFrom = currentResource.getDerivedFrom(); List updatedDerivedFrom = updateInfoResource.getDerivedFrom(); if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null || updatedDerivedFrom.isEmpty()) { log.trace("Update normative types"); return Either.left(true); } String derivedFromCurrent = currentDerivedFrom.get(0); String derivedFromUpdated = updatedDerivedFrom.get(0); if (!derivedFromCurrent.equals(derivedFromUpdated)) { if (!hasBeenCertified) { Either validateDerivedFromExistsEither = validateDerivedFromExist(null, updateInfoResource, null); if (validateDerivedFromExistsEither.isRight()) { return validateDerivedFromExistsEither; } } else { Either validateDerivedFromExtending = validateDerivedFromExtending(null, currentResource, updateInfoResource, null); if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left().value()) { log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance"); return validateDerivedFromExtending; } } } return Either.left(true); } private Either validateDerivedFromExist(User user, Resource resource, AuditingActionEnum actionEnum) { if (resource.getDerivedFrom() == null || resource.getDerivedFrom().isEmpty()) { return Either.left(true); } String templateName = resource.getDerivedFrom().get(0); Either dataModelResponse = toscaOperationFacade .validateToscaResourceNameExists(templateName); if (dataModelResponse.isRight()) { StorageOperationStatus storageStatus = dataModelResponse.right().value(); BeEcompErrorManager.getInstance().logBeDaoSystemError("Create Resource - validateDerivedFromExist"); log.debug("request to data model failed with error: {}", storageStatus); ResponseFormat responseFormat = componentsUtils .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus), resource); log.trace("audit before sending response"); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } else if (!dataModelResponse.left().value()) { log.info("resource template with name: {}, does not exists", templateName); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PARENT_RESOURCE_NOT_FOUND); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } return Either.left(true); } // Tal G for extending inheritance US815447 private Either validateDerivedFromExtending(User user, Resource currentResource, Resource updateInfoResource, AuditingActionEnum actionEnum) { String currentTemplateName = currentResource.getDerivedFrom().get(0); String updatedTemplateName = updateInfoResource.getDerivedFrom().get(0); Either dataModelResponse = toscaOperationFacade .validateToscaResourceNameExtends(currentTemplateName, updatedTemplateName); if (dataModelResponse.isRight()) { StorageOperationStatus storageStatus = dataModelResponse.right().value(); BeEcompErrorManager.getInstance() .logBeDaoSystemError("Create/Update Resource - validateDerivingFromExtendingType"); ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(storageStatus), currentResource); log.trace("audit before sending response"); componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum); return Either.right(responseFormat); } if (!dataModelResponse.left().value()) { log.info("resource template with name {} does not inherit as original {}", updatedTemplateName, currentTemplateName); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND); componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum); return Either.right(responseFormat); } return Either.left(true); } public Either validateDerivedFromNotEmpty(User user, Resource resource, AuditingActionEnum actionEnum) { log.debug("validate resource derivedFrom field"); if ((resource.getDerivedFrom() == null) || (resource.getDerivedFrom().isEmpty()) || (resource.getDerivedFrom().get(0)) == null || (resource.getDerivedFrom().get(0).trim().isEmpty())) { log.info("derived from (template) field is missing for the resource"); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } return Either.left(true); } private Either validateResourceNameExists(Resource resource) { Either resourceOperationResponse = toscaOperationFacade .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType()); if (resourceOperationResponse.isLeft()) { if (!resourceOperationResponse.left().value()) { return Either.left(false); } else { log.debug("resource with name: {}, already exists", resource.getName()); ResponseFormat errorResponse = componentsUtils.getResponseFormat( ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName()); return Either.right(errorResponse); } } log.debug("error while validateResourceNameExists for resource: {}", resource.getName()); ResponseFormat errorResponse = componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(resourceOperationResponse.right().value())); return Either.right(errorResponse); } private Either validateCategory(User user, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) { List categories = resource.getCategories(); if (categories == null || categories.size() == 0) { log.debug("Resource category is empty"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } if (categories.size() > 1) { log.debug("Must be only one category for resource"); ResponseFormat responseFormat = componentsUtils.getResponseFormat( ActionStatus.COMPONENT_TOO_MUCH_CATEGORIES, ComponentTypeEnum.RESOURCE.getValue()); return Either.right(responseFormat); } CategoryDefinition category = categories.get(0); List subcategories = category.getSubcategories(); if (subcategories == null || subcategories.size() == 0) { log.debug("Missinig subcategory for resource"); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.COMPONENT_MISSING_SUBCATEGORY); return Either.right(responseFormat); } if (subcategories.size() > 1) { log.debug("Must be only one sub category for resource"); ResponseFormat responseFormat = componentsUtils .getResponseFormat(ActionStatus.RESOURCE_TOO_MUCH_SUBCATEGORIES); return Either.right(responseFormat); } SubCategoryDefinition subcategory = subcategories.get(0); if (!ValidationUtils.validateStringNotEmpty(category.getName())) { log.debug("Resource category is empty"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } if (!ValidationUtils.validateStringNotEmpty(subcategory.getName())) { log.debug("Resource category is empty"); ResponseFormat responseFormat = componentsUtils.getResponseFormat( ActionStatus.COMPONENT_MISSING_SUBCATEGORY, ComponentTypeEnum.RESOURCE.getValue()); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } Either validateCategory = validateCategoryListed(category, subcategory, inTransaction); if (validateCategory.isRight()) { ResponseFormat responseFormat = validateCategory.right().value(); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); return Either.right(responseFormat); } return Either.left(true); } private Either validateCategoryListed(CategoryDefinition category, SubCategoryDefinition subcategory, boolean inTransaction) { if (category != null && subcategory != null) { log.debug("validating resource category {} against valid categories list", category); Either, ActionStatus> categories = elementDao .getAllCategories(NodeTypeEnum.ResourceNewCategory, inTransaction); if (categories.isRight()) { log.debug("failed to retrive resource categories from Titan"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(categories.right().value()); return Either.right(responseFormat); } List categoryList = categories.left().value(); for (CategoryDefinition cat : categoryList) { if (cat.getName().equals(category.getName())) { for (SubCategoryDefinition subcat : cat.getSubcategories()) { if (subcat.getName().equals(subcategory.getName())) { return Either.left(true); } } log.debug( "SubCategory {} is not part of resource category group. Resource subcategory valid values are {}", subcategory, cat.getSubcategories()); return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue())); } } log.debug("Category {} is not part of resource category group. Resource category valid values are {}", category, categoryList); return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue())); } return Either.left(false); } public Either validateVendorReleaseName(User user, Resource resource, AuditingActionEnum actionEnum) { String vendorRelease = resource.getVendorRelease(); log.debug("validate vendor relese name"); if (!ValidationUtils.validateStringNotEmpty(vendorRelease)) { log.info("vendor relese name is missing."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_RELEASE); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); return Either.right(errorResponse); } Either validateVendorReleaseResponse = validateVendorReleaseName(vendorRelease); if (validateVendorReleaseResponse.isRight()) { ResponseFormat responseFormat = validateVendorReleaseResponse.right().value(); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); } return validateVendorReleaseResponse; } public Either validateVendorReleaseName(String vendorRelease) { if (vendorRelease != null) { if (!ValidationUtils.validateVendorReleaseLength(vendorRelease)) { log.info("vendor release exceds limit."); ResponseFormat errorResponse = componentsUtils.getResponseFormat( ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH); return Either.right(errorResponse); } if (!ValidationUtils.validateVendorRelease(vendorRelease)) { log.info("vendor release is not valid."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_RELEASE); return Either.right(errorResponse); } return Either.left(true); } return Either.left(false); } private Either validateVendorName(User user, Resource resource, AuditingActionEnum actionEnum) { String vendorName = resource.getVendorName(); if (!ValidationUtils.validateStringNotEmpty(vendorName)) { log.info("vendor name is missing."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_NAME); componentsUtils.auditResource(errorResponse, user, resource, actionEnum); return Either.right(errorResponse); } Either validateVendorNameResponse = validateVendorName(vendorName); if (validateVendorNameResponse.isRight()) { ResponseFormat responseFormat = validateVendorNameResponse.right().value(); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); } return validateVendorNameResponse; } private Either validateResourceVendorModelNumber(User user, Resource resource, AuditingActionEnum actionEnum) { String resourceVendorModelNumber = resource.getResourceVendorModelNumber(); Either validateResourceVendorModelNumber = validateResourceVendorModelNumber( resourceVendorModelNumber); if (validateResourceVendorModelNumber.isRight()) { ResponseFormat responseFormat = validateResourceVendorModelNumber.right().value(); componentsUtils.auditResource(responseFormat, user, resource, actionEnum); } return validateResourceVendorModelNumber; } private Either validateVendorName(String vendorName) { if (vendorName != null) { if (!ValidationUtils.validateVendorNameLength(vendorName)) { log.info("vendor name exceds limit."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH); return Either.right(errorResponse); } if (!ValidationUtils.validateVendorName(vendorName)) { log.info("vendor name is not valid."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_NAME); return Either.right(errorResponse); } return Either.left(true); } return Either.left(false); } private Either validateResourceVendorModelNumber(String resourceVendorModelNumber) { if (StringUtils.isEmpty(resourceVendorModelNumber)) { return Either.left(true); } else { if (!ValidationUtils.validateResourceVendorModelNumberLength(resourceVendorModelNumber)) { log.info("resource vendor model number exceeds limit."); ResponseFormat errorResponse = componentsUtils.getResponseFormat( ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH); return Either.right(errorResponse); } // resource vendor model number is currently validated as vendor // name if (!ValidationUtils.validateVendorName(resourceVendorModelNumber)) { log.info("resource vendor model number is not valid."); ResponseFormat errorResponse = componentsUtils .getResponseFormat(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER); return Either.right(errorResponse); } return Either.left(true); } } private Either validateCost(User user, Resource resource, AuditingActionEnum actionEnum) { String cost = resource.getCost(); if (cost != null) { if (!ValidationUtils.validateCost(cost)) { log.debug("resource cost is invalid."); ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); return Either.right(errorResponse); } } return Either.left(true); } private Either validateLicenseType(User user, Resource resource, AuditingActionEnum actionEnum) { log.debug("validate licenseType"); String licenseType = resource.getLicenseType(); if (licenseType != null) { List licenseTypes = ConfigurationManager.getConfigurationManager().getConfiguration() .getLicenseTypes(); if (!licenseTypes.contains(licenseType)) { log.debug("License type {} isn't configured"); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT); if (actionEnum != null) { // In update case, no audit is required componentsUtils.auditResource(responseFormat, user, resource, actionEnum); } return Either.right(responseFormat); } } return Either.left(true); } private Either processUpdateOfDerivedFrom(Resource currentResource, Resource updatedResource, String userId, boolean shouldLock, boolean inTransaction) { Either deleteArtifactByInterface = null; if (updatedResource.getDerivedFrom() != null) { log.debug("Starting derived from update for resource {}", updatedResource.getUniqueId()); log.debug("1. Removing interface artifacts from graph"); // Remove all interface artifacts of resource String resourceId = updatedResource.getUniqueId(); Map interfaces = currentResource.getInterfaces(); if (interfaces != null) { Collection values = interfaces.values(); for (InterfaceDefinition interfaceDefinition : values) { String interfaceType = interfaceTypeOperation.getShortInterfaceName(interfaceDefinition); log.trace("Starting interface artifacts removal for interface type {}", interfaceType); Map operations = interfaceDefinition.getOperationsMap(); if (operations != null) { for (Entry operationEntry : operations.entrySet()) { Operation operation = operationEntry.getValue(); ArtifactDefinition implementation = operation.getImplementationArtifact(); if (implementation != null) { String uniqueId = implementation.getUniqueId(); log.debug("Removing interface artifact definition {}, operation {}, interfaceType {}", uniqueId, operationEntry.getKey(), interfaceType); // only thing that transacts and locks here deleteArtifactByInterface = artifactsBusinessLogic.deleteArtifactByInterface(resourceId, userId, uniqueId, true); if (deleteArtifactByInterface.isRight()) { log.debug("Couldn't remove artifact definition with id {}", uniqueId); if (!inTransaction) { titanDao.rollback(); } return Either.right(deleteArtifactByInterface.right().value()); } } else { log.trace("No implementation found for operation {} - nothing to delete", operationEntry.getKey()); } } } else { log.trace("No operations found for interface type {}", interfaceType); } } } log.debug("2. Removing properties"); Either, StorageOperationStatus> findPropertiesOfNode = propertyOperation .deleteAllPropertiesAssociatedToNode(NodeTypeEnum.Resource, resourceId); if (findPropertiesOfNode.isRight() && !findPropertiesOfNode.right().value().equals(StorageOperationStatus.OK)) { log.debug("Failed to remove all properties of resource"); if (!inTransaction) titanDao.rollback(); return Either.right(componentsUtils.getResponseFormat( componentsUtils.convertFromStorageResponse(findPropertiesOfNode.right().value()))); } } else { log.debug("Derived from wasn't changed during update"); } if (!inTransaction) titanDao.commit(); return Either.left(true); } /**** Auditing *******************/ protected static IElementOperation getElementDao(Class class1, ServletContext context) { WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR); WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context); return webApplicationContext.getBean(class1); } public ICapabilityTypeOperation getCapabilityTypeOperation() { return capabilityTypeOperation; } public void setCapabilityTypeOperation(ICapabilityTypeOperation capabilityTypeOperation) { this.capabilityTypeOperation = capabilityTypeOperation; } public Either validatePropertiesDefaultValues(Resource resource) { log.debug("validate resource properties default values"); Either eitherResult = Either.left(true); List properties = resource.getProperties(); String type = null; String innerType = null; if (properties != null) { for (PropertyDefinition property : properties) { if (!propertyOperation.isPropertyTypeValid(property)) { log.info("Invalid type for property"); ResponseFormat responseFormat = componentsUtils.getResponseFormat( ActionStatus.INVALID_PROPERTY_TYPE, property.getType(), property.getName()); eitherResult = Either.right(responseFormat); break; } Either, ResponseFormat> allDataTypes = getAllDataTypes( applicationDataTypeCache); if (allDataTypes.isRight()) { return Either.right(allDataTypes.right().value()); } type = property.getType(); if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) { ImmutablePair propertyInnerTypeValid = propertyOperation .isPropertyInnerTypeValid(property, allDataTypes.left().value()); innerType = propertyInnerTypeValid.getLeft(); if (!propertyInnerTypeValid.getRight().booleanValue()) { log.info("Invalid inner type for property"); ResponseFormat responseFormat = componentsUtils.getResponseFormat( ActionStatus.INVALID_PROPERTY_INNER_TYPE, innerType, property.getName()); eitherResult = Either.right(responseFormat); break; } } if (!propertyOperation.isPropertyDefaultValueValid(property, allDataTypes.left().value())) { log.info("Invalid default value for property"); ResponseFormat responseFormat; if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) { responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE, property.getName(), type, innerType, property.getDefaultValue()); } else { responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_DEFAULT_VALUE, property.getName(), type, property.getDefaultValue()); } eitherResult = Either.right(responseFormat); break; } } } return eitherResult; } @Override public Either, ResponseFormat> deleteMarkedComponents() { return deleteMarkedComponents(ComponentTypeEnum.RESOURCE); } @Override public ComponentInstanceBusinessLogic getComponentInstanceBL() { return componentInstanceBusinessLogic; } private String getComponentTypeForResponse(Component component) { String componentTypeForResponse = "SERVICE"; if (component instanceof Resource) { componentTypeForResponse = ((Resource) component).getResourceType().name(); } return componentTypeForResponse; } private Either, ResponseFormat> createGroupsFromYaml(String yamlFileName, Map toscaJson, Resource resource) { Map groups = new HashMap(); Either, ResponseFormat> result = Either.left(groups); Either, ResultStatusEnum> eitherNodesTemlates = ImportUtils .findFirstToscaMapElement(toscaJson, ToscaTagNamesEnum.GROUPS); if (eitherNodesTemlates.isLeft()) { Map jsonNodeTemplates = eitherNodesTemlates.left().value(); if (jsonNodeTemplates != null && false == jsonNodeTemplates.isEmpty()) { Iterator> nodesNameValue = jsonNodeTemplates.entrySet().iterator(); while (nodesNameValue.hasNext()) { Entry groupNameValue = nodesNameValue.next(); String groupName = groupNameValue.getKey(); Either eitherNode = createGroupInfo(groupName, groupNameValue.getValue()); if (eitherNode.isRight()) { String message = "Failed when creating group: " + groupNameValue.getKey() + " for resource:" + resource.getName(); BeEcompErrorManager.getInstance().logInternalFlowError("ImportResource", message, ErrorSeverity.INFO); return Either.right(eitherNode.right().value()); } else { GroupDefinition groupDefinition = eitherNode.left().value(); groups.put(groupName, groupDefinition); } } } } return result; } private Either, ResponseFormat> createInputsFromYaml(String yamlFileName, Map toscaJson, Resource resource) { Either, ResultStatusEnum> inputs = ImportUtils.getInputs(toscaJson); if (inputs.isRight()) { String message = "Failed when creating inputs: for resource:" + resource.getName(); BeEcompErrorManager.getInstance().logInternalFlowError("ImportResource", message, ErrorSeverity.INFO); Map resultMap = new HashMap<>(); return Either.left(resultMap); } Either, ResponseFormat> result = Either.left(inputs.left().value()); return result; } @SuppressWarnings("unchecked") private Either createGroupInfo(String groupName, Object groupTemplateJson) { GroupDefinition groupInfo = new GroupDefinition(); groupInfo.setName(groupName); Either result = Either.left(groupInfo); try { if (groupTemplateJson != null && groupTemplateJson instanceof Map) { Map groupTemplateJsonMap = (Map) groupTemplateJson; String groupType = (String) groupTemplateJsonMap.get(ToscaTagNamesEnum.TYPE.getElementName()); if (!StringUtils.isEmpty(groupType)) { groupInfo.setType(groupType); } else { log.debug("The 'type' member is not found under group {}", groupName); return Either .right(componentsUtils.getResponseFormat(ActionStatus.GROUP_MISSING_GROUP_TYPE, groupName)); } if (groupTemplateJsonMap.containsKey(ToscaTagNamesEnum.DESCRIPTION.getElementName())) { groupInfo.setDescription( (String) groupTemplateJsonMap.get(ToscaTagNamesEnum.DESCRIPTION.getElementName())); } if (groupTemplateJsonMap.containsKey(ToscaTagNamesEnum.MEMBERS.getElementName())) { Object members = groupTemplateJsonMap.get(ToscaTagNamesEnum.MEMBERS.getElementName()); if (members != null) { if (members instanceof List) { Map membersLoaded = new HashMap<>(); List membersAsList = (List) members; for (Object member : membersAsList) { membersLoaded.put(member.toString(), ""); } groupInfo.setMembers(membersLoaded); } else { log.debug("The 'members' member is not of type list under group {}", groupName); return Either .right(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE)); } } } if (groupTemplateJsonMap.containsKey(ToscaTagNamesEnum.PROPERTIES.getElementName())) { Object properties = groupTemplateJsonMap.get(ToscaTagNamesEnum.PROPERTIES.getElementName()); Either, ResponseFormat> regResponse = createPropertiesValueModuleFromYaml( properties, groupName, groupType); if (regResponse.isRight()) return Either.right(regResponse.right().value()); if (regResponse.left().value().size() > 0) { groupInfo.convertFromGroupProperties(regResponse.left().value()); } } } else { result = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE)); } } catch (Exception e) { BeEcompErrorManager.getInstance().logBeSystemError("Import Resource - create group"); log.debug("error when creating group, message:{}", e.getMessage(), e); result = Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_YAML)); } return result; } @SuppressWarnings("unchecked") private Either, ResponseFormat> createPropertiesValueModuleFromYaml(Object properties, String groupName, String groupType) { List result = new ArrayList<>(); if (properties == null) { return Either.left(result); } Either groupTypeRes = groupTypeOperation .getLatestGroupTypeByType(groupType, true); if (groupTypeRes.isRight()) { return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_TYPE_IS_INVALID, groupType)); } Map gtProperties = new HashMap<>(); GroupTypeDefinition groupTypeDefinition = groupTypeRes.left().value(); List propertiesDef = groupTypeDefinition.getProperties(); if (propertiesDef != null) { gtProperties = propertiesDef.stream().collect(Collectors.toMap(p -> p.getName(), p -> p)); } if (properties != null) { if (properties instanceof Map) { Map props = (Map) properties; for (Entry entry : props.entrySet()) { String propName = entry.getKey(); Object value = entry.getValue(); PropertyDefinition gtDefinition = gtProperties.get(propName); if (gtDefinition == null) { return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_PROPERTY_NOT_FOUND, propName, groupName, groupType)); } ToscaPropertyType type = ToscaPropertyType.isValidType(gtDefinition.getType()); String convertedValue = null; if (value != null) { if (type == null || value instanceof Map || value instanceof List) { convertedValue = gson.toJson(value); } else { convertedValue = value.toString(); } } GroupProperty groupProperty = new GroupProperty(); groupProperty.setValue(convertedValue); groupProperty.setName(propName); log.trace("After building group property {}", groupProperty); result.add(groupProperty); } } } return Either.left(result); } public Either getLatestResourceFromCsarUuid(String csarUuid, User user) { // validate user if (user != null) { Either userValidation = validateUserExists(user, "Get resource from csar UUID", false); if (userValidation.isRight()) { return Either.right(userValidation.right().value()); } } // get resource from csar uuid Either either = toscaOperationFacade .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUuid, ""); if (either.isRight()) { ResponseFormat resp = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND, csarUuid); return Either.right(resp); } return Either.left(either.left().value()); } @Override public Either, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs( String componentId, ComponentTypeEnum componentTypeEnum, String userId, String searchText) { return null; } private Either>, ResponseFormat> getValidComponentInstanceCapabilities( String resourceId, Map> defaultCapabilities, Map> uploadedCapabilities) { ResponseFormat responseFormat; Map> validCapabilitiesMap = new HashMap<>(); for (Entry> uploadedCapabilitiesEntry : uploadedCapabilities.entrySet()) { String capabilityType = uploadedCapabilitiesEntry.getValue().get(0).getType(); if (!defaultCapabilities.containsKey(capabilityType)) { responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, capabilityType); return Either.right(responseFormat); } else { CapabilityDefinition defaultCapability; if (CollectionUtils.isNotEmpty(defaultCapabilities.get(capabilityType).get(0).getProperties())) { defaultCapability = defaultCapabilities.get(capabilityType).get(0); } else { Either getFullComponentRes = toscaOperationFacade .getToscaFullElement(resourceId); if (getFullComponentRes.isRight()) { log.debug("Failed to get full component {}. Status is {}. ", resourceId, getFullComponentRes.right().value()); responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, resourceId); return Either.right(responseFormat); } defaultCapability = getFullComponentRes.left().value().getCapabilities().get(capabilityType).get(0); } if (CollectionUtils.isEmpty(defaultCapability.getProperties()) && CollectionUtils.isNotEmpty(uploadedCapabilitiesEntry.getValue().get(0).getProperties())) { log.debug("Failed to validate capability {} of component {}. Property list is empty. ", defaultCapability.getName(), resourceId); log.debug( "Failed to update capability property values. Property list of fetched capability {} is empty. ", defaultCapability.getName()); responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, resourceId); return Either.right(responseFormat); } if (CollectionUtils.isNotEmpty(defaultCapability.getProperties()) && CollectionUtils.isNotEmpty(uploadedCapabilitiesEntry.getValue().get(0).getProperties())) { Either validationRes = validateUniquenessUpdateUploadedComponentInstanceCapability( defaultCapability, uploadedCapabilitiesEntry.getValue().get(0)); if (validationRes.isRight()) { responseFormat = componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS, validationRes.right().value()); return Either.right(responseFormat); } } List validCapabilityList = new ArrayList<>(); validCapabilityList.add(defaultCapability); validCapabilitiesMap.put(uploadedCapabilitiesEntry.getKey(), validCapabilityList); } } return Either.left(validCapabilitiesMap); } private Either validateUniquenessUpdateUploadedComponentInstanceCapability( CapabilityDefinition defaultCapability, UploadCapInfo uploadedCapability) { List validProperties = new ArrayList<>(); Map defaultProperties = defaultCapability.getProperties().stream() .collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())); List uploadedProperties = uploadedCapability.getProperties(); for (UploadPropInfo property : uploadedProperties) { String propertyName = property.getName().toLowerCase(); String propertyType = property.getType(); ComponentInstanceProperty validProperty; if (defaultProperties.containsKey(propertyName)) { if (propertyType != null && !defaultProperties.get(propertyName).getType().equals(propertyType)) { return Either.right(propertyName); } } validProperty = new ComponentInstanceProperty(); validProperty.setName(propertyName); if (property.getValue() != null) validProperty.setValue(property.getValue().toString()); validProperty.setDescription(property.getDescription()); validProperty.setPassword(property.isPassword()); validProperties.add(validProperty); } defaultCapability.setProperties(validProperties); return Either.left(true); } private Either>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation( List artifactPathAndNameList, List existingArtifactsToHandle, Resource resource, User user) { EnumMap> nodeTypeArtifactsToHandle = new EnumMap<>( ArtifactOperationEnum.class); Wrapper responseWrapper = new Wrapper<>(); Either>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either .left(nodeTypeArtifactsToHandle); ; try { // add all found Csar artifacts to list to upload List artifactsToUpload = new ArrayList<>(artifactPathAndNameList); List artifactsToUpdate = new ArrayList<>(); List artifactsToDelete = new ArrayList<>(); for (NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) { ArtifactDefinition foundArtifact; if (!existingArtifactsToHandle.isEmpty()) { foundArtifact = existingArtifactsToHandle.stream() .filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName())).findFirst() .orElse(null); if (foundArtifact != null) { if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()) == currNewArtifact .getArtifactType()) { if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) { currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId()); // if current artifact already exists, but has // different content, add him to the list to // update artifactsToUpdate.add(currNewArtifact); } // remove found artifact from the list of existing // artifacts to handle, because it was already // handled existingArtifactsToHandle.remove(foundArtifact); // and remove found artifact from the list to // upload, because it should either be updated or be // ignored artifactsToUpload.remove(currNewArtifact); } else { log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName()); ResponseFormat responseFormat = ResponseFormatManager.getInstance().getResponseFormat( ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType().name(), foundArtifact.getArtifactType()); AuditingActionEnum auditingAction = artifactsBusinessLogic .detectAuditingType(artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE), foundArtifact.getArtifactChecksum()); artifactsBusinessLogic.handleAuditing(auditingAction, resource, resource.getUniqueId(), user, null, null, foundArtifact.getUniqueId(), responseFormat, resource.getComponentType(), null); responseWrapper.setInnerElement(responseFormat); break; } } } } if (responseWrapper.isEmpty()) { for (ArtifactDefinition currArtifact : existingArtifactsToHandle) { if (currArtifact.getIsFromCsar()) { artifactsToDelete.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null, ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); } else { artifactsToUpdate.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null, ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); } } } if (responseWrapper.isEmpty()) { if (!artifactsToUpload.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload); if (!artifactsToUpdate.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate); if (!artifactsToDelete.isEmpty()) nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete); } if (!responseWrapper.isEmpty()) { nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement()); } } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); responseWrapper.setInnerElement(responseFormat); log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e); } return nodeTypeArtifactsToHandleRes; } private ImmutablePair buildNestedToscaResourceName(String nodeResourceType, String vfResourceName, String nodeTypeFullName) { String actualType; String actualVfName; if (ResourceTypeEnum.CVFC.name().equals(nodeResourceType)) { actualVfName = vfResourceName + ResourceTypeEnum.CVFC.name(); actualType = ResourceTypeEnum.VFC.name(); } else { actualVfName = vfResourceName; actualType = nodeResourceType; } StringBuilder toscaResourceName = new StringBuilder(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX); String nameWithouNamespacePrefix = nodeTypeFullName .substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length()); String[] findTypes = nameWithouNamespacePrefix.split("\\."); String resourceType = findTypes[0]; String actualName = nameWithouNamespacePrefix.substring(resourceType.length()); if (actualName.startsWith(Constants.ABSTRACT)) { toscaResourceName.append(resourceType.toLowerCase()).append('.') .append(ValidationUtils.convertToSystemName(actualVfName)); } else { toscaResourceName.append(actualType.toLowerCase()).append('.') .append(ValidationUtils.convertToSystemName(actualVfName)).append('.').append(Constants.ABSTRACT); } StringBuilder previousToscaResourceName = new StringBuilder(toscaResourceName); return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(), previousToscaResourceName .append(actualName.substring(actualName.split("\\.")[1].length() + 1).toLowerCase()) .toString()); } public ICacheMangerOperation getCacheManagerOperation() { return cacheManagerOperation; } public void setCacheManagerOperation(ICacheMangerOperation cacheManagerOperation) { this.cacheManagerOperation = cacheManagerOperation; } ///////////////////////////////////////// DataModel ///////////////////////////////////////// refactoring///////////////////////////////////////////// @Override public Either getUiComponentDataTransferByComponentId(String resourceId, List dataParamsToReturn) { ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn); Either resourceResultEither = toscaOperationFacade.getToscaElement(resourceId, paramsToRetuen); if (resourceResultEither.isRight()) { if (resourceResultEither.right().value().equals(StorageOperationStatus.NOT_FOUND)) { log.debug("Failed to found resource with id {} ", resourceId); Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId)); } log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn); return Either.right(componentsUtils.getResponseFormatByResource( componentsUtils.convertFromStorageResponse(resourceResultEither.right().value()), "")); } Resource resource = resourceResultEither.left().value(); UiComponentDataTransfer dataTransfer = UiComponentDataConverter.getUiDataTransferFromResourceByParams(resource, dataParamsToReturn); return Either.left(dataTransfer); } @Override public Either shouldUpgradeToLatestDerived(Component clonedComponent) { Resource resource = (Resource) clonedComponent; if (ModelConverter.isAtomicComponent(resource.getResourceType())) { Either shouldUpgradeToLatestDerived = toscaOperationFacade .shouldUpgradeToLatestDerived(resource); if (shouldUpgradeToLatestDerived.isRight()) { return Either.right( componentsUtils.convertFromStorageResponse(shouldUpgradeToLatestDerived.right().value())); } return Either.left(shouldUpgradeToLatestDerived.left().value()); } else { return super.shouldUpgradeToLatestDerived(clonedComponent); } } private Either validateAndUpdateInterfaces(String resourceId, Resource resourceUpdate) { Either resourceStorageOperationStatusEither = toscaOperationFacade.getToscaElement(resourceId); if (resourceStorageOperationStatusEither.isRight()) { StorageOperationStatus errorStatus = resourceStorageOperationStatusEither.right().value(); log.error("Failed to fetch resource information by resource id {}, error {}", resourceId, errorStatus); return Either.right(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus))); } Resource storedResource = resourceStorageOperationStatusEither.left().value(); Map storedResourceInterfaces = storedResource.getInterfaces(); if(!storedResource.getName().equals(resourceUpdate.getName()) ) { Collection interfaceDefinitionListFromToscaName = InterfaceUtils .getInterfaceDefinitionListFromToscaName(storedResource.getInterfaces().values(), storedResource.getName()); for (InterfaceDefinition interfaceDefinition : storedResourceInterfaces.values()) { Either updateInterfaceDefinitionEither = updateInterfaceDefinition(resourceUpdate, interfaceDefinition, interfaceDefinitionListFromToscaName); if(updateInterfaceDefinitionEither.isRight()) { return Either.right(updateInterfaceDefinitionEither.right().value()); } } } return Either.left(Boolean.TRUE); } private Either updateInterfaceDefinition(Resource resourceUpdate, InterfaceDefinition interfaceDefinition, Collection interfaceDefinitionListFromToscaName) { interfaceDefinitionListFromToscaName.forEach(interfaceDefinitionFromList -> { if(interfaceDefinitionFromList.getToscaResourceName().equals(interfaceDefinition .getToscaResourceName())) { log.info("Going to Update interface definition toscaResourceName {} to {}", interfaceDefinitionFromList.getToscaResourceName(), InterfaceUtils.createInterfaceToscaResourceName(resourceUpdate.getName())); interfaceDefinition.setToscaResourceName(InterfaceUtils .createInterfaceToscaResourceName(resourceUpdate.getName())); } } ); try { Either interfaceUpdate = interfaceOperation .updateInterface(resourceUpdate.getUniqueId(), interfaceDefinition); if (interfaceUpdate.isRight()) { log.error("Failed to Update interface {}. Response is {}. ", resourceUpdate.getName(), interfaceUpdate.right().value()); titanDao.rollback(); return Either.right(componentsUtils .getResponseFormat(componentsUtils.convertFromStorageResponse(interfaceUpdate.right().value(), ComponentTypeEnum.RESOURCE))); } } catch (Exception e) { log.error("Exception occurred during update interface toscaResourceName : {}", e.getMessage(), e); return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } return Either.left( interfaceDefinition); } }