X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Fmain%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Fcomponents%2Fimpl%2FServiceImportBusinessLogic.java;h=8671d9e27ac9239ee832a4e3f9c3ece705310072;hb=8d59b022d1b35a4549ff4a1f3aeea0c11214c6fb;hp=550e2d9ea0ec466e19ba00416d2e109eddc5904d;hpb=f6fa8c64c4cb4d9607deedd7339b8e74d224c7b8;p=sdc.git diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogic.java index 550e2d9ea0..8671d9e27a 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogic.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogic.java @@ -13,88 +13,125 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + package org.openecomp.sdc.be.components.impl; import static java.util.stream.Collectors.joining; import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toMap; import static org.apache.commons.collections.CollectionUtils.isNotEmpty; +import static org.openecomp.sdc.be.components.impl.CsarValidationUtils.TOSCA_METADATA_PATH_PATTERN; +import static org.openecomp.sdc.be.components.impl.CsarValidationUtils.TOSCA_META_ENTRY_DEFINITIONS; +import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement; import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement; import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue; import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; import fj.data.Either; +import java.io.IOException; +import java.io.InputStream; +import java.io.StringReader; +import java.lang.reflect.Method; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Optional; +import java.util.Properties; import java.util.Set; +import java.util.TreeSet; +import java.util.concurrent.atomic.AtomicReference; import java.util.regex.Pattern; +import java.util.stream.Collectors; +import javax.validation.constraints.NotNull; import lombok.Getter; import lombok.Setter; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.StringEscapeUtils; +import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; +import org.json.simple.JSONObject; import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic; import org.openecomp.sdc.be.components.csar.CsarBusinessLogic; import org.openecomp.sdc.be.components.csar.CsarInfo; -import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine; +import org.openecomp.sdc.be.components.csar.ServiceCsarInfo; import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum; import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo; +import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException; +import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException; import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException; import org.openecomp.sdc.be.components.impl.exceptions.ComponentException; +import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData; import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils; import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter; import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic; import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction; import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic; -import org.openecomp.sdc.be.components.path.ForwardingPathValidator; -import org.openecomp.sdc.be.components.validation.NodeFilterValidator; -import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation; -import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator; -import org.openecomp.sdc.be.components.validation.component.ComponentValidator; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils; -import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter; -import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction; import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; +import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction; +import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition; 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.datatypes.tosca.ToscaGetFunctionType; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts; import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.ArtifactTypeDefinition; +import org.openecomp.sdc.be.model.AttributeDefinition; 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.ComponentInstanceAttribute; 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.DataTypeDefinition; import org.openecomp.sdc.be.model.DistributionStatusEnum; import org.openecomp.sdc.be.model.GroupDefinition; +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.NodeTypeDefinition; import org.openecomp.sdc.be.model.NodeTypeInfo; +import org.openecomp.sdc.be.model.NodeTypeMetadata; +import org.openecomp.sdc.be.model.NodeTypesMetadataList; import org.openecomp.sdc.be.model.Operation; +import org.openecomp.sdc.be.model.OutputDefinition; import org.openecomp.sdc.be.model.ParsedToscaYamlInfo; +import org.openecomp.sdc.be.model.PolicyDefinition; import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.RelationshipImpl; import org.openecomp.sdc.be.model.RelationshipInfo; @@ -102,29 +139,35 @@ 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.Service; +import org.openecomp.sdc.be.model.UploadAttributeInfo; import org.openecomp.sdc.be.model.UploadComponentInstanceInfo; +import org.openecomp.sdc.be.model.UploadInterfaceInfo; import org.openecomp.sdc.be.model.UploadNodeFilterInfo; 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.jsonjanusgraph.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations; -import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation; -import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +import org.openecomp.sdc.be.model.normatives.ToscaTypeMetadata; import org.openecomp.sdc.be.model.operations.StorageException; -import org.openecomp.sdc.be.model.operations.api.IElementOperation; -import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation; -import org.openecomp.sdc.be.model.operations.api.IGroupOperation; -import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation; +import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation; +import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation; +import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation; import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; +import org.openecomp.sdc.be.model.operations.impl.ModelOperation; +import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; +import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; import org.openecomp.sdc.be.tosca.CsarUtils; +import org.openecomp.sdc.be.tosca.ToscaExportHandler; +import org.openecomp.sdc.be.ui.model.OperationUi; import org.openecomp.sdc.be.utils.TypeUtils; +import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import org.openecomp.sdc.common.api.Constants; @@ -132,6 +175,8 @@ import org.openecomp.sdc.common.datastructure.Wrapper; import org.openecomp.sdc.common.kpi.api.ASDCKpiApi; import org.openecomp.sdc.common.log.wrappers.Logger; import org.openecomp.sdc.common.util.ValidationUtils; +import org.openecomp.sdc.common.zip.ZipUtils; +import org.openecomp.sdc.common.zip.exception.ZipException; import org.openecomp.sdc.exception.ResponseFormat; import org.springframework.beans.factory.annotation.Autowired; import org.yaml.snakeyaml.Yaml; @@ -139,12 +184,11 @@ import org.yaml.snakeyaml.Yaml; @Getter @Setter @org.springframework.stereotype.Component("serviceImportBusinessLogic") -public class ServiceImportBusinessLogic{ +public class ServiceImportBusinessLogic { - private final UiComponentDataConverter uiComponentDataConverter; + protected static final String CREATE_RESOURCE = "Create Resource"; private static final String INITIAL_VERSION = "0.1"; - private static final String CREATE_RESOURCE = "Create Resource"; - private static final String IN_RESOURCE = " in resource {} "; + private static final String IN_RESOURCE = " in resource {} "; private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name "; private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} "; private static final String CERTIFICATION_ON_IMPORT = "certification on import"; @@ -152,129 +196,586 @@ public class ServiceImportBusinessLogic{ private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes"; private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate"; private static final String CATEGORY_IS_EMPTY = "Resource category is empty"; + private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class); + private final ComponentsUtils componentsUtils; + private final ToscaOperationFacade toscaOperationFacade; + private final ServiceBusinessLogic serviceBusinessLogic; + private final CsarBusinessLogic csarBusinessLogic; + private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic; + private final LifecycleBusinessLogic lifecycleBusinessLogic; + private final CompositionBusinessLogic compositionBusinessLogic; + private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic; + private final ServiceImportParseLogic serviceImportParseLogic; + private final GroupBusinessLogic groupBusinessLogic; + private final PolicyBusinessLogic policyBusinessLogic; + private final ResourceImportManager resourceImportManager; + private final JanusGraphDao janusGraphDao; + private final ArtifactsBusinessLogic artifactsBusinessLogic; + private final ArtifactTypeImportManager artifactTypeImportManager; + private final IGraphLockOperation graphLockOperation; + private final ToscaFunctionService toscaFunctionService; + private final DataTypeBusinessLogic dataTypeBusinessLogic; + private final ArtifactTypeOperation artifactTypeOperation; + private final GroupTypeImportManager groupTypeImportManager; + private final GroupTypeOperation groupTypeOperation; + private final CapabilityTypeImportManager capabilityTypeImportManager; + private final CapabilityTypeOperation capabilityTypeOperation; + private final InterfaceLifecycleOperation interfaceLifecycleTypeOperation; + private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager; + private final ModelOperation modelOperation; + private ApplicationDataTypeCache applicationDataTypeCache; + + public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic, + final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade, + final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic, + final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic, + final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic, + final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic, + final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic, + final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao, + final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService, + final DataTypeBusinessLogic dataTypeBusinessLogic, final ArtifactTypeOperation artifactTypeOperation, + final ArtifactTypeImportManager artifactTypeImportManager, final GroupTypeImportManager groupTypeImportManager, + final GroupTypeOperation groupTypeOperation, + final InterfaceLifecycleOperation interfaceLifecycleTypeOperation, + final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager, + final CapabilityTypeImportManager capabilityTypeImportManager, + final CapabilityTypeOperation capabilityTypeOperation, + final ModelOperation modelOperation) { + this.componentsUtils = componentsUtils; + this.toscaOperationFacade = toscaOperationFacade; + this.serviceBusinessLogic = serviceBusinessLogic; + this.csarBusinessLogic = csarBusinessLogic; + this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic; + this.lifecycleBusinessLogic = lifecycleBusinessLogic; + this.compositionBusinessLogic = compositionBusinessLogic; + this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic; + this.serviceImportParseLogic = serviceImportParseLogic; + this.groupBusinessLogic = groupBusinessLogic; + this.policyBusinessLogic = policyBusinessLogic; + this.resourceImportManager = resourceImportManager; + this.janusGraphDao = janusGraphDao; + this.artifactsBusinessLogic = artifactsBusinessLogic; + this.graphLockOperation = graphLockOperation; + this.toscaFunctionService = toscaFunctionService; + this.dataTypeBusinessLogic = dataTypeBusinessLogic; + this.artifactTypeOperation = artifactTypeOperation; + this.artifactTypeImportManager = artifactTypeImportManager; + this.groupTypeImportManager = groupTypeImportManager; + this.groupTypeOperation = groupTypeOperation; + this.interfaceLifecycleTypeOperation = interfaceLifecycleTypeOperation; + this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager; + this.capabilityTypeImportManager = capabilityTypeImportManager; + this.capabilityTypeOperation = capabilityTypeOperation; + this.modelOperation = modelOperation; + } @Autowired - private ServiceBusinessLogic serviceBusinessLogic; - public ServiceBusinessLogic getServiceBusinessLogic() { - return serviceBusinessLogic; + public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) { + this.applicationDataTypeCache = applicationDataTypeCache; } - public void setServiceBusinessLogic( - ServiceBusinessLogic serviceBusinessLogic) { - this.serviceBusinessLogic = serviceBusinessLogic; - } + public Service updateServiceFromToscaTemplate(final String serviceId, final User modifier, final String data) { + final Either serviceResponseFormatEither = serviceBusinessLogic.getService(serviceId, modifier); + if (serviceResponseFormatEither.isRight()) { + throw new ByActionStatusComponentException(ActionStatus.SERVICE_NOT_FOUND, serviceId); + } + final Service serviceOriginal = serviceResponseFormatEither.left().value(); + final Map metadata = (Map) new Yaml().loadAs(data, Map.class).get("metadata"); + validateServiceMetadataBeforeCreate(serviceOriginal, metadata); - @Autowired - private CsarBusinessLogic csarBusinessLogic; - @Autowired - protected ComponentsUtils componentsUtils; - @Autowired - protected ToscaOperationFacade toscaOperationFacade; - @Autowired - private CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic; - @Autowired - private LifecycleBusinessLogic lifecycleBusinessLogic; - @Autowired - private CompositionBusinessLogic compositionBusinessLogic; - @Autowired - private ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic; - @Autowired - private ServiceImportParseLogic serviceImportParseLogic; + final Service newService = cloneServiceIdentifications(serviceOriginal); + final Map payload = new HashMap<>(); + payload.put("Definitions/service-" + metadata.get("name") + "-template.yml", data.getBytes()); + updateServiceMetadata(newService, metadata); + return createService(newService, AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE, modifier, payload, null); + } - private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class); - @Autowired - public ServiceImportBusinessLogic(IElementOperation elementDao, - IGroupOperation groupOperation, - IGroupInstanceOperation groupInstanceOperation, - IGroupTypeOperation groupTypeOperation, - GroupBusinessLogic groupBusinessLogic, - InterfaceOperation interfaceOperation, - InterfaceLifecycleOperation interfaceLifecycleTypeOperation, - ArtifactsBusinessLogic artifactsBusinessLogic, - IDistributionEngine distributionEngine, ComponentInstanceBusinessLogic componentInstanceBusinessLogic, - ServiceDistributionValidation serviceDistributionValidation, ForwardingPathValidator forwardingPathValidator, - UiComponentDataConverter uiComponentDataConverter, NodeFilterOperation serviceFilterOperation, - NodeFilterValidator serviceFilterValidator, ArtifactsOperations artifactToscaOperation, - ComponentContactIdValidator componentContactIdValidator, - ComponentNameValidator componentNameValidator, - ComponentTagsValidator componentTagsValidator, - ComponentValidator componentValidator, - ComponentIconValidator componentIconValidator, - ComponentProjectCodeValidator componentProjectCodeValidator, - ComponentDescriptionValidator componentDescriptionValidator) { - this.componentInstanceBusinessLogic = componentInstanceBusinessLogic; - this.uiComponentDataConverter = uiComponentDataConverter; - } - - private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic; - - public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map csarUIPayload, String payloadName) { - log.debug("enter createService"); - service.setCreatorUserId(user.getUserId()); - service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - service.setVersion(INITIAL_VERSION); - service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel()); - service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED); - service.setInstantiationType("A-la-carte"); - service.setEnvironmentContext("General_Revenue-Bearing"); - service.setEcompGeneratedNaming(true); + public Service updateServiceFromToscaModel(final String serviceId, final User modifier, final @NotNull InputStream fileToUpload) { + final Either serviceResponseFormatEither = serviceBusinessLogic.getService(serviceId, modifier); + if (serviceResponseFormatEither.isRight()) { + throw new ByActionStatusComponentException(ActionStatus.SERVICE_NOT_FOUND, serviceId); + } + final Service serviceOriginal = serviceResponseFormatEither.left().value(); + Map csar = null; + try { + csar = ZipUtils.readZip(fileToUpload.readAllBytes(), false); + } catch (final ZipException | IOException e) { + log.info("Failed to unzip received csar {}", serviceId, e); + } + if (csar == null) { + throw new ByActionStatusComponentException(ActionStatus.CSAR_NOT_FOUND); + } + final byte[] mainYamlBytes = readMainYamlFile(csar); + final Map metadata = (Map) new Yaml().loadAs(new String(mainYamlBytes), Map.class).get("metadata"); + validateServiceMetadataBeforeCreate(serviceOriginal, metadata); + final Service newService = cloneServiceIdentifications(serviceOriginal); + updateServiceMetadata(newService, metadata); + return createService(newService, AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL, modifier, csar, null); + } + private byte[] readMainYamlFile(final Map csar) { + final Pattern pattern = Pattern.compile(TOSCA_METADATA_PATH_PATTERN); + final Optional keyOp = csar.keySet().stream().filter(k -> pattern.matcher(k).matches()).findAny(); + if (keyOp.isEmpty()) { + throw new ByActionStatusComponentException(ActionStatus.ARTIFACT_NOT_FOUND_IN_CSAR, TOSCA_METADATA_PATH_PATTERN, ""); + } + final Properties props = new Properties(); try { - serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction); + final String propStr = new String(csar.get(keyOp.get())); + props.load(new StringReader(propStr.replace("\\", "\\\\"))); + } catch (IOException e) { + throw new ByActionStatusComponentException(ActionStatus.ARTIFACT_NOT_FOUND_IN_CSAR, TOSCA_META_ENTRY_DEFINITIONS, ""); + } + final String mainYamlFileName = props.getProperty(TOSCA_META_ENTRY_DEFINITIONS); + final byte[] mainYamlBytes = csar.get(mainYamlFileName); + if (mainYamlBytes == null) { + throw new ByActionStatusComponentException(ActionStatus.ARTIFACT_NOT_FOUND_IN_CSAR, mainYamlFileName, ""); + } + return mainYamlBytes; + } + + private Service cloneServiceIdentifications(final Service serviceOriginal) { + final Service newService = new Service(serviceOriginal.getComponentMetadataDefinition()); + newService.setCategories(serviceOriginal.getCategories()); + newService.setInvariantUUID(serviceOriginal.getInvariantUUID()); + newService.setUniqueId(serviceOriginal.getUniqueId()); + newService.setName(serviceOriginal.getName()); + newService.setUUID(serviceOriginal.getUUID()); + return newService; + } + + private void validateServiceMetadataBeforeCreate(final Service service, final Map metadata) { + if (MapUtils.isEmpty(metadata)) { + throw new ByActionStatusComponentException(ActionStatus.MISSING_SERVICE_METADATA); + } + final String uuid = metadata.get("UUID"); + if (!service.getUUID().equals(uuid)) { + throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "UUID"); + } + final String invariantUUID = metadata.get("invariantUUID"); + if (!service.getInvariantUUID().equals(invariantUUID)) { + throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "invariantUUID"); + } + final String name = metadata.get("name"); + if (!service.getName().equals(name)) { + throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "name"); + } + final String version = metadata.get("template_version"); + if (!service.getVersion().equals(version)) { + throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "template_version"); + } + } + public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map csarUIPayload, + String payloadName) { + log.debug("enter createService"); + if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) { + service.setCreatorUserId(user.getUserId()); + service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + service.setVersion(INITIAL_VERSION); + service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel()); + service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED); + } + try { + final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction); + if (serviceBeforeCreate.isRight()) { + throw new ComponentException(ActionStatus.GENERAL_ERROR); + } log.debug("enter createService,validateServiceBeforeCreate success"); String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName; - - log.debug("enter createService,get csarUUID:{}", csarUUID); - csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID); + if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) { + log.debug("enter createService,get csarUUID:{}", csarUUID); + csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID); + } log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID); - return createServiceFromCsar(service, user, csarUIPayload, csarUUID); - }catch (Exception e){ - log.debug("Exception occured when createService,error is:{}",e.getMessage(),e); - //ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); + return createServiceFromCsar(service, user, csarUIPayload, csarUUID, auditingAction); + } catch (final ComponentException e) { + log.debug("Exception occurred when createService: {}", e.getMessage(), e); + throw e; + } catch (final Exception e) { + log.debug("Exception occurred when createService: {}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected Service createServiceFromCsar(Service service, User user, Map csarUIPayload, String csarUUID) { + private void updateServiceMetadata(final Service service, final Map metadata) { + metadata.entrySet().forEach(s -> { + final Optional find = + Arrays.stream(service.getClass().getMethods()).filter(method -> method.getName().equalsIgnoreCase("set" + s.getKey())).findAny(); + if (find.isPresent()) { + try { + find.get().invoke(service, s.getValue()); + } catch (final Exception e) { + log.warn("Unable to set '{}' with value '{}'", s.getKey(), s.getValue()); + } + } + }); + } + + protected Service createServiceFromCsar(Service service, User user, Map csarUIPayload, String csarUUID, + AuditingActionEnum auditingAction) { log.trace("************* created successfully from YAML, resource TOSCA "); try { - CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID); + final ServiceCsarInfo csarInfo; + if (AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction)) { + csarInfo = new ServiceCsarInfo(user, csarUUID, csarUIPayload, service.getName(), service.getModel(), + csarUIPayload.keySet().iterator().next(), new String(csarUIPayload.values().iterator().next()), true, modelOperation); + } else { + csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID, auditingAction); + } + final String serviceModel = service.getModel(); + final Map dataTypesToCreate = getDatatypesToCreate(serviceModel, csarInfo); + if (MapUtils.isNotEmpty(dataTypesToCreate)) { + dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), serviceModel, true); + dataTypesToCreate.keySet().forEach(key -> + applicationDataTypeCache.reload(serviceModel, UniqueIdBuilder.buildDataTypeUid(serviceModel, key)) + ); + } + + final Map artifactTypesToCreate = getArtifactTypesToCreate(serviceModel, csarInfo); + if (MapUtils.isNotEmpty(artifactTypesToCreate)) { + artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), serviceModel, true); + } - Map nodeTypesInfo = csarInfo.extractNodeTypesInfo(); - Either>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic - .findNodeTypesArtifactsToHandle( - nodeTypesInfo, csarInfo, service); + final List nodeTypesToCreate = getNodeTypesToCreate(serviceModel, csarInfo); + if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) { + ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(csarInfo, service); + createNodeTypes(nodeTypesToCreate, parsedToscaYamlInfo.getInstances(), serviceModel, csarInfo.getModifier()); + } + + final Map groupTypesToCreate = getGroupTypesToCreate(serviceModel, csarInfo); + if (MapUtils.isNotEmpty(groupTypesToCreate)) { + final Map toscaTypeMetadata = fillToscaTypeMetadata(groupTypesToCreate); + final ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(new Yaml().dump(groupTypesToCreate), toscaTypeMetadata); + groupTypeImportManager.createGroupTypes(toscaTypeImportData, serviceModel, true); + } + + final Map interfaceTypesToCreate = getInterfaceTypesToCreate(serviceModel, csarInfo); + if (MapUtils.isNotEmpty(interfaceTypesToCreate)) { + interfaceLifecycleTypeImportManager.createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), serviceModel, true); + } + + final Map capabilityTypesToCreate = getCapabilityTypesToCreate(serviceModel, csarInfo); + if (MapUtils.isNotEmpty(capabilityTypesToCreate)) { + capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), serviceModel, true); + } + + Map nodeTypesInfo = csarInfo.extractTypesInfo(); + Either>>, ResponseFormat> findNodeTypesArtifactsToHandleRes + = serviceImportParseLogic.findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service); if (findNodeTypesArtifactsToHandleRes.isRight()) { - log.debug("failed to find node types for update with artifacts during import csar {}. ", - csarInfo.getCsarUUID()); + log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID()); throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value()); } - Service cService = createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), - nodeTypesInfo, csarInfo, findNodeTypesArtifactsToHandleRes.left().value(), true, false, - null); - return cService; - }catch (Exception e){ - log.debug("Exception occured when createServiceFromCsar,error is:{}",e.getMessage(),e); + return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo, + findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId(), auditingAction); + } catch (final ComponentException e) { + log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e); + throw e; + } catch (final Exception e) { + log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, - String yamlName, Map nodeTypesInfo, CsarInfo csarInfo, - Map>> nodeTypesArtifactsToCreate, - boolean shouldLock, boolean inTransaction, String nodeName) { + private Map fillToscaTypeMetadata(final Map groupTypesToCreate) { + final Map toscaTypeMetadata = new HashMap<>(); + groupTypesToCreate.entrySet().forEach(entry -> { + final ToscaTypeMetadata metadata = new ToscaTypeMetadata(); + metadata.setIcon(getIconFromGroupType(entry.getValue())); + metadata.setDisplayName(extractDisplayName(entry.getKey())); + toscaTypeMetadata.put(entry.getKey(), metadata); + }); + return toscaTypeMetadata; + } + + private String extractDisplayName(final String key) { + final String[] split = key.split("\\."); + return split[split.length - 1]; + } + + private String getIconFromGroupType(final Object value) { + final Either groupType = groupTypeOperation.getLatestGroupTypeByType( + (String) ((LinkedHashMap) value).get(ToscaTagNamesEnum.DERIVED_FROM.getElementName()), null); + if (groupType.isLeft()) { + return groupType.left().value().getIcon(); + } + return null; + } + + private Map getGroupTypesToCreate(final String model, final CsarInfo csarInfo) { + final Map groupTypesToCreate = new HashMap<>(); + final Map groupTypes = csarInfo.getGroupTypes(); + if (MapUtils.isNotEmpty(groupTypes)) { + for (final Entry entry : groupTypes.entrySet()) { + final Either result + = groupTypeOperation.getGroupTypeByUid(UniqueIdBuilder.buildGroupTypeUid(model, entry.getKey(), "1.0")); + if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) { + groupTypesToCreate.put(entry.getKey(), entry.getValue()); + log.info("Deploying new group type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID()); + } + } + } + return groupTypesToCreate; + } + + private Map getCapabilityTypesToCreate(final String model, final CsarInfo csarInfo) { + final Map capabilityTypesToCreate = new HashMap<>(); + final Map capabilityTypes = csarInfo.getCapabilityTypes(); + if (MapUtils.isNotEmpty(capabilityTypes)) { + for (final Entry entry : capabilityTypes.entrySet()) { + final Either result + = capabilityTypeOperation.getCapabilityType(UniqueIdBuilder.buildCapabilityTypeUid(model, entry.getKey())); + if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) { + capabilityTypesToCreate.put(entry.getKey(), entry.getValue()); + log.info("Deploying new capability type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID()); + } + } + } + return capabilityTypesToCreate; + } + + private Map getDatatypesToCreate(final String model, final CsarInfo csarInfo) { + final Map dataTypesToCreate = new HashMap<>(); + + for (final Entry dataTypeEntry : csarInfo.getDataTypes().entrySet()) { + final Either result = applicationDataTypeCache.get(model, + UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey())); + if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) { + dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue()); + log.info("Deploying unknown type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID()); + } + if (hasNewProperties(result, (Map>) dataTypeEntry.getValue())) { + dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue()); + log.info("Deploying new version of type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID()); + } + } + return dataTypesToCreate; + } + + private Map getArtifactTypesToCreate(final String model, final CsarInfo csarInfo) { + final Map artifactTypesToCreate = new HashMap<>(); + final Map artifactTypesMap = csarInfo.getArtifactTypes(); + if (MapUtils.isNotEmpty(artifactTypesMap)) { + for (final Entry artifactTypeEntry : artifactTypesMap.entrySet()) { + final Either result = + artifactTypeOperation.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(model, artifactTypeEntry.getKey())); + if (result.isRight() && StorageOperationStatus.NOT_FOUND.equals(result.right().value())) { + artifactTypesToCreate.put(artifactTypeEntry.getKey(), artifactTypeEntry.getValue()); + log.info("Deploying new artifact type={}, to model={}, from package={}", + artifactTypeEntry.getKey(), model, csarInfo.getCsarUUID()); + } + } + } + return artifactTypesToCreate; + } + + private Map getInterfaceTypesToCreate(final String model, final CsarInfo csarInfo) { + final Map interfaceTypesToCreate = new HashMap<>(); + Map interfacetypeMap = csarInfo.getInterfaceTypes(); + + interfacetypeMap.entrySet().forEach(interfacetypeDef -> { + Either interfaceDefinition = + interfaceLifecycleTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(model, interfacetypeDef.getKey())); + if (interfaceDefinition.isRight() && interfaceDefinition.right().value().equals(StorageOperationStatus.NOT_FOUND)) { + interfaceTypesToCreate.put(interfacetypeDef.getKey(), interfacetypeDef.getValue()); + } + }); + return interfaceTypesToCreate; + } + + private boolean hasNewProperties(final Either result, + final Map> dataType) { + return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null + && result.left().value().getProperties().size() != dataType.get("properties").size(); + } + + private void createNodeTypes(List nodeTypesToCreate, Map instancesFromCsar, String model, + User user) { + NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList(); + List nodeTypeMetadataList = new ArrayList<>(); + final Map allTypesToCreate = new HashMap<>(); + nodeTypesToCreate.forEach(nodeType -> { + allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue()); + nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata()); + }); + nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList); + resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, instancesFromCsar, user, model, true, false); + } + + private List getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) { + List namesOfNodeTypesToCreate = new ArrayList<>(); + + for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) { + Either result = toscaOperationFacade + .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model); + if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) { + namesOfNodeTypesToCreate.add(nodeTypeDefinition); + } else if (result.isLeft()) { + Resource latestResource = (Resource) result.left().value(); + Entry existingMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(), + latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId()); + Map newMappedToscaTemplate = (Map) nodeTypeDefinition.getMappedNodeType().getValue(); + Map combinedMappedToscaTemplate = + getNewChangesToToscaTemplate(newMappedToscaTemplate, (Map) existingMappedToscaTemplate.getValue()); + if (!combinedMappedToscaTemplate.equals(existingMappedToscaTemplate.getValue())) { + if (latestResource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative()) { + nodeTypeDefinition.getNodeTypeMetadata().setNormative(true); + } + existingMappedToscaTemplate.setValue(combinedMappedToscaTemplate); + nodeTypeDefinition.setMappedNodeType(existingMappedToscaTemplate); + namesOfNodeTypesToCreate.add(nodeTypeDefinition); + } + } + } + return namesOfNodeTypesToCreate; + } + + private Entry getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) { + String assetToToscaTemplate = assetToscaTemplate.getUniqueId(); + ImmutablePair toscaTemplate = artifactsBusinessLogic. + handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null); + Map mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right)); + Either, ImportUtils.ResultStatusEnum> eitherNodeTypes = + findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES); + if (eitherNodeTypes.isRight()) { + throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE); + } + return eitherNodeTypes.left().value().entrySet().iterator().next(); + } + private Map getNewChangesToToscaTemplate(Map newMappedToscaTemplate, + Map existingMappedToscaTemplate) { + Map combinedMappedToscaTemplate = new HashMap<>(existingMappedToscaTemplate); + combinePropertiesIntoToscaTemplate((Map) newMappedToscaTemplate.get("properties"), + (Map) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate); + combineAttributesIntoToscaTemplate((Map) newMappedToscaTemplate.get("attributes"), + (Map) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate); + combineRequirementsIntoToscaTemplate((List>) newMappedToscaTemplate.get("requirements"), + (List>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate); + combineCapabilitiesIntoToscaTemplate((Map) newMappedToscaTemplate.get("capabilities"), + (Map) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate); + combineInterfacesIntoToscaTemplate((Map>) newMappedToscaTemplate.get("interfaces"), + (Map>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate); + return combinedMappedToscaTemplate; + } + + private void combineInterfacesIntoToscaTemplate(Map> newInterfaces, + Map> existingInterfaces, + Map combinedMappedToscaTemplate) { + Map> combinedInterfaces = combineAdditionalInterfaces(newInterfaces, existingInterfaces); + if ((MapUtils.isEmpty(existingInterfaces) && MapUtils.isNotEmpty(combinedInterfaces)) + || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) { + combinedMappedToscaTemplate.put("interfaces", combinedInterfaces); + } + } + + private void combineCapabilitiesIntoToscaTemplate(Map newCapabilities, Map existingCapabilities, + Map combinedMappedToscaTemplate) { + Map combinedCapabilities = combineEntries(newCapabilities, existingCapabilities); + if ((MapUtils.isEmpty(existingCapabilities) && MapUtils.isNotEmpty(combinedCapabilities)) || + (MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) { + combinedMappedToscaTemplate.put("capabilities", combinedCapabilities); + } + } + + private void combineRequirementsIntoToscaTemplate(List> newRequirements, List> existingRequirements, + Map combinedMappedToscaTemplate) { + List> combinedRequirements = combineAdditionalRequirements(newRequirements, existingRequirements); + if ((CollectionUtils.isEmpty(existingRequirements) && CollectionUtils.isNotEmpty(combinedRequirements)) + || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) { + combinedMappedToscaTemplate.put("requirements", combinedRequirements); + } + } + + private void combineAttributesIntoToscaTemplate(Map newAttributes, Map existingAttributes, + Map combinedMappedToscaTemplate) { + Map combinedAttributes = combineEntries(newAttributes, existingAttributes); + if ((MapUtils.isEmpty(existingAttributes) && MapUtils.isNotEmpty(combinedAttributes)) || + (MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) { + combinedMappedToscaTemplate.put("attributes", combinedAttributes); + } + } + + private void combinePropertiesIntoToscaTemplate(Map newProperties, Map existingProperties, + Map combinedMappedToscaTemplate) { + Map combinedProperties = combineEntries(newProperties, existingProperties); + if ((MapUtils.isEmpty(existingProperties) && MapUtils.isNotEmpty(combinedProperties)) || + (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) { + combinedMappedToscaTemplate.put("properties", combinedProperties); + } + } + + private Map> combineAdditionalInterfaces(Map> newInterfaces, + Map> existingInterfaces) { + if (MapUtils.isNotEmpty(newInterfaces) && MapUtils.isNotEmpty(existingInterfaces) && newInterfaces.equals(existingInterfaces)) { + return new HashMap<>(existingInterfaces); + } + if (MapUtils.isEmpty(newInterfaces)) { + newInterfaces = new HashMap<>(); + } + Map> combinedEntries = new HashMap<>(newInterfaces); + if (MapUtils.isEmpty(existingInterfaces)) { + return combinedEntries; + } + existingInterfaces.entrySet().forEach(interfaceDef -> { + combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals((interfaceDef.getValue()).get("type"))) + .findFirst().ifPresentOrElse((interFace) -> { + interFace.getValue().putAll(interfaceDef.getValue()); + }, () -> { + combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue()); + }); + }); + return combinedEntries; + } + + private List> combineAdditionalRequirements(List> newReqs, + List> existingResourceReqs) { + if (CollectionUtils.isNotEmpty(newReqs) && CollectionUtils.isNotEmpty(existingResourceReqs) && newReqs.equals(existingResourceReqs)) { + return new ArrayList<>(existingResourceReqs); + } + if (CollectionUtils.isEmpty(existingResourceReqs)) { + existingResourceReqs = new ArrayList<>(); + } + Set> combinedReqs = new TreeSet<>((map1, map2) -> + map1.keySet().equals(map2.keySet()) ? 0 : map1.keySet().iterator().next().compareTo(map2.keySet().iterator().next())); + combinedReqs.addAll(existingResourceReqs); + if (CollectionUtils.isEmpty(newReqs)) { + return new ArrayList<>(combinedReqs); + } + combinedReqs.addAll(newReqs); + return new ArrayList<>(combinedReqs); + } + + private Map combineEntries(Map newMap, Map existingMap) { + if (MapUtils.isNotEmpty(newMap) && MapUtils.isNotEmpty(existingMap) && newMap.equals(existingMap)) { + return new HashMap<>(existingMap); + } + if (MapUtils.isEmpty(newMap)) { + newMap = new HashMap<>(); + } + Map combinedEntries = new HashMap<>(newMap); + if (MapUtils.isEmpty(existingMap)) { + return combinedEntries; + } + combinedEntries.putAll(existingMap); + return combinedEntries; + } + + protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map nodeTypesInfo, + CsarInfo csarInfo, + Map>> nodeTypesArtifactsToCreate, + boolean shouldLock, boolean inTransaction, String nodeName, final String userId, + AuditingActionEnum auditingAction) + throws BusinessLogicException { List createdArtifacts = new ArrayList<>(); Service createdService; CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter(); try { - ParsedToscaYamlInfo - parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service); - if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances())) { - throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); - } + ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic + .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service); log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName()); csfyp.setYamlName(yamlName); csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo); @@ -283,11 +784,11 @@ public class ServiceImportBusinessLogic{ csfyp.setNodeTypesInfo(nodeTypesInfo); csfyp.setCsarInfo(csarInfo); csfyp.setNodeName(nodeName); - - createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp); + createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId, + auditingAction); log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName()); - } catch (ComponentException e) { - log.debug("create Service From Yaml failed,get ComponentException:{}", e); + } catch (ComponentException | BusinessLogicException e) { + log.debug("Create Service from yaml failed", e); throw e; } catch (StorageException e) { log.debug("create Service From Yaml failed,get StorageException:{}", e); @@ -297,8 +798,10 @@ public class ServiceImportBusinessLogic{ } protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative, - Map>> nodeTypesArtifactsToCreate, - boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp) { + Map>> nodeTypesArtifactsToCreate, + boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp, + final String userId, AuditingActionEnum auditingAction) + throws BusinessLogicException { List nodeTypesNewCreatedArtifacts = new ArrayList<>(); String yamlName = csfyp.getYamlName(); @@ -308,103 +811,262 @@ public class ServiceImportBusinessLogic{ Map nodeTypesInfo = csfyp.getNodeTypesInfo(); CsarInfo csarInfo = csfyp.getCsarInfo(); String nodeName = csfyp.getNodeName(); - if (shouldLock) { Either lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE); if (lockResult.isRight()) { - serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(lockResult.right().value()); } log.debug("name is locked {} status = {}", service.getSystemName(), lockResult); } + boolean rollback = false; try { + log.trace("************* Adding properties to service from interface yaml {}", yamlName); + Map properties = parsedToscaYamlInfo.getProperties(); + if (properties != null && !properties.isEmpty()) { + final List propertiesList = new ArrayList<>(); + properties.forEach((propertyName, propertyDefinition) -> { + propertyDefinition.setName(propertyName); + propertiesList.add(propertyDefinition); + }); + service.setProperties(propertiesList); + } log.trace("************* createResourceFromYaml before full create resource {}", yamlName); - service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative); + service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative, auditingAction); log.trace("************* Going to add inputs from yaml {}", yamlName); - Map inputs = parsedToscaYamlInfo.getInputs(); service = serviceImportParseLogic.createInputsOnService(service, inputs); - log.trace("************* Finish to add inputs from yaml {}", yamlName); - - Map uploadComponentInstanceInfoMap = parsedToscaYamlInfo - .getInstances(); + log.trace("************* Finished to add inputs from yaml {}", yamlName); + ListDataDefinition substitutionFilterProperties = + parsedToscaYamlInfo.getSubstitutionFilterProperties(); + service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties); + log.trace("************* Added Substitution filter from interface yaml {}", yamlName); + Map uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances(); log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName); - - service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, - topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, - nodeTypesArtifactsToCreate, nodeName); + service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml, + nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName); log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName); - Either, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic - .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName()); + log.trace("************* Going to add outputs from yaml {}", yamlName); + Map outputs = parsedToscaYamlInfo.getOutputs(); + service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId); + log.trace("************* Finished to add outputs from yaml {}", yamlName); + + Either, ResponseFormat> validateUpdateVfGroupNamesRes + = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName()); if (validateUpdateVfGroupNamesRes.isRight()) { - serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(validateUpdateVfGroupNamesRes.right().value()); } 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(service, groups); if (createGroupsOnResource.isRight()) { - serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(createGroupsOnResource.right().value()); } service = createGroupsOnResource.left().value(); - log.trace("************* Going to add artifacts from yaml {}", yamlName); - NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, - nodeTypesArtifactsToCreate); - - Either createArtifactsEither = createOrUpdateArtifacts( - ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, createdArtifacts, yamlName, - csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); + Either createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies()); + if (createPoliciesOnResource.isRight()) { + throw new ComponentException(createPoliciesOnResource.right().value()); + } + service = createPoliciesOnResource.left().value(); + log.trace("************* Going to add artifacts from yaml {}", yamlName); + Either createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, + createdArtifacts, yamlName, csarInfo, service, inTransaction, shouldLock); if (createArtifactsEither.isRight()) { - serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(createArtifactsEither.right().value()); } service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId()); + service = updateInputs(service, userId, parsedToscaYamlInfo.getSubstitutionMappingProperties()); + ASDCKpiApi.countCreatedResourcesKPI(); return service; - } catch (ComponentException | StorageException e) { + } catch (Exception e) { + rollback = true; serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts); throw e; } finally { if (!inTransaction) { - serviceBusinessLogic.janusGraphDao.commit(); + if (rollback) { + janusGraphDao.rollback(); + } else { + janusGraphDao.commit(); + } } if (shouldLock) { - serviceBusinessLogic.graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), - NodeTypeEnum.Resource); + graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service); + } + } + } + + private Service updateInputs(final Service component, final String userId, final Map> substitutionMappingProperties) { + final List inputs = component.getInputs(); + if (CollectionUtils.isNotEmpty(inputs)) { + final List componentInstances = component.getComponentInstances(); + final String componentUniqueId = component.getUniqueId(); + List propertyMissingNames = new ArrayList<>(); + for (final InputDefinition input : inputs) { + boolean isSubMapProp = false; + if (substitutionMappingProperties != null && !substitutionMappingProperties.isEmpty()) { + isSubMapProp = substitutionMappingProperties.entrySet().stream() + .anyMatch(stringEntry -> stringEntry.getValue().get(0).equals(input.getName())); + } + if (!isSubMapProp && isInputFromComponentInstanceProperty(input.getName(), componentInstances)) { + associateInputToComponentInstanceProperty(userId, input, componentInstances, componentUniqueId); + } else { + String propertyName = associateInputToServiceProperty(userId, input, component, substitutionMappingProperties); + if (StringUtils.isNotBlank(propertyName)) { + propertyMissingNames.add(propertyName); + } + } + } + if (CollectionUtils.isNotEmpty(propertyMissingNames)) { + throw new ComponentException( + componentsUtils.getResponseFormat(ActionStatus.MISSING_PROPERTIES_ERROR, propertyMissingNames.toString())); + } + Either, StorageOperationStatus> either = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId); + if (either.isRight()) { + throw new ComponentException(ActionStatus.GENERAL_ERROR); + } + } + + return component; + } + + private boolean isInputFromComponentInstanceProperty(final String inputName, final List componentInstances) { + + if (CollectionUtils.isNotEmpty(componentInstances)) { + for (ComponentInstance instance : componentInstances) { + for (PropertyDefinition instanceProperty : instance.getProperties()) { + if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) { + for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) { + if (inputName.equals(getInputValueDataDefinition.getInputName())) { + return true; + } + } + } + } } } + return false; } - protected Either createOrUpdateArtifacts( - ArtifactsBusinessLogic.ArtifactOperationEnum operation, List createdArtifacts, - String yamlFileName, CsarInfo csarInfo, Resource preparedResource, - NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts, boolean inTransaction, boolean shouldLock) { + private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input, + final List componentInstances, + String componentUniqueId) { + + String componentInstanceId = null; + ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(); + + outer: + for (ComponentInstance instance : componentInstances) { + for (PropertyDefinition instanceProperty : instance.getProperties()) { + if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) { + for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) { + if (input.getName().equals(getInputValueDataDefinition.getInputName())) { + componentInstanceId = instance.getUniqueId(); + componentInstanceProperty = new ComponentInstanceProperty(instanceProperty); + break outer; + } + } + } + } + } + + //unmapping instance property declared inputs from substitution mapping + input.setMappedToComponentProperty(false); + // From Instance + updateInput(input, componentInstanceProperty, userId, componentInstanceId); + + final Either>, StorageOperationStatus> either = + toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId, + Collections.singletonList(componentInstanceProperty)), componentUniqueId); + if (either.isRight()) { + throw new ComponentException(ActionStatus.GENERAL_ERROR); + } + } + + private String associateInputToServiceProperty(final String userId, + final InputDefinition input, final Service component, + final Map> substitutionMappingProperties) { + final List properties = component.getProperties(); + if (CollectionUtils.isNotEmpty(properties) && MapUtils.isNotEmpty(substitutionMappingProperties)) { + AtomicReference propertyNameFromInput = new AtomicReference<>(" "); + substitutionMappingProperties.entrySet().forEach(stringEntry -> { + if (stringEntry.getValue().get(0).equals(input.getName())) { + propertyNameFromInput.set(stringEntry.getKey()); + } + }); + + final Optional propDefOptional = + properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput.get())) + .findFirst(); + if (propDefOptional.isPresent()) { + // From SELF + final String componentUniqueId = component.getUniqueId(); + final PropertyDefinition propertyDefinition = propDefOptional.get(); + updateProperty(propertyDefinition, input, componentUniqueId); + final JSONObject jsonObject = new JSONObject(); + jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName()); + propertyDefinition.setValue(jsonObject.toJSONString()); + updateInput(input, propertyDefinition, userId, componentUniqueId); + + final Either either + = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition); + if (either.isRight()) { + throw new ComponentException(ActionStatus.GENERAL_ERROR); + } + } else { + input.setMappedToComponentProperty(false); + return propertyNameFromInput.get(); + } + } + return ""; + } + + private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) { + propertyDefinition.setParentUniqueId(componentUniqueId); + final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition(); + getInputValueDataDefinition.setInputId(input.getUniqueId()); + getInputValueDataDefinition.setInputName(input.getName()); + getInputValueDataDefinition.setPropName(propertyDefinition.getName()); + propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition)); + } + + private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition, + final String userId, final String componentUniqueId) { + input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition))); + input.setInstanceUniqueId(componentUniqueId); + input.setOwnerId(userId); + input.setPropertyId(propertyDefinition.getUniqueId()); + input.setParentPropertyType(propertyDefinition.getType()); + } + + protected Either createOrUpdateArtifacts(ArtifactsBusinessLogic.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 + Map>> nodeTypesArtifactsToHandle = + nodeTypeInfoToUpdateArtifacts .getNodeTypesArtifactsToHandle(); if (preparedResource.getResourceType() == ResourceTypeEnum.VF) { if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) { - Either, ResponseFormat> handleNodeTypeArtifactsRes = - handleNodeTypeArtifacts(preparedResource, nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true); + 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, - new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction); + new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction); log.trace("************* Finished to add artifacts from yaml {}", yamlFileName); if (createdCsarArtifactsEither.isRight()) { return createdCsarArtifactsEither; @@ -414,28 +1076,28 @@ public class ServiceImportBusinessLogic{ return Either.left(resource); } - protected Either handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, - List createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock, - boolean inTransaction) { + protected Either handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List createdArtifacts, + ArtifactOperationInfo artifactOperation, boolean shouldLock, + boolean inTransaction) { if (csarInfo.getCsar() != null) { createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction); - - Either eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, - createdArtifacts, shouldLock, inTransaction, artifactOperation); + 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); + 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); - + Either, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils + .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils); if (artifacsMetaCsarStatus.isLeft()) { - return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction, artifacsMetaCsarStatus); + return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction, + artifacsMetaCsarStatus); } else { return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction); } @@ -443,7 +1105,8 @@ public class ServiceImportBusinessLogic{ return Either.left(resource); } - protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation, boolean shouldLock, boolean inTransaction) { + protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation, + boolean shouldLock, boolean inTransaction) { String vendorLicenseModelId = null; String vfLicenseModelId = null; if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) { @@ -459,32 +1122,31 @@ public class ServiceImportBusinessLogic{ } } } - 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, true, 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, true, shouldLock, inTransaction); + 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, true, 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, true, shouldLock, inTransaction); } - protected Either getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo, List createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock, boolean inTransaction, Either, ResponseFormat> artifacsMetaCsarStatus) { + private Either getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo, + List createdArtifacts, + ArtifactOperationInfo artifactOperation, boolean shouldLock, + boolean inTransaction, + Either, ResponseFormat> artifacsMetaCsarStatus) { try { 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); + .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts); } else { Either result = csarArtifactsAndGroupsBusinessLogic - .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, - createdArtifacts, shouldLock, inTransaction); + .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock, + inTransaction); if ((result.left().value() instanceof Resource) && result.isLeft()) { Resource service1 = (Resource) result.left().value(); createArtifactsFromCsar = Either.left(service1); @@ -497,31 +1159,32 @@ public class ServiceImportBusinessLogic{ return Either.right(createArtifactsFromCsar.right().value()); } return Either.left(createArtifactsFromCsar.left().value()); - }catch(Exception e) { + } catch (Exception e) { log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e); return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); } } private Either createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component, - List createdArtifacts, boolean shouldLock, boolean inTransaction, - ArtifactOperationInfo artifactOperation) { + List createdArtifacts, + boolean shouldLock, boolean inTransaction, + ArtifactOperationInfo artifactOperation) { Either resStatus = null; Map>> collectedWarningMessages = new HashMap<>(); try { Either, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages); if (artifactPathAndNameList.isRight()) { - return Either.right(getComponentsUtils().getResponseFormatByArtifactId( - ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value())); + return Either.right( + getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value())); } EnumMap> vfCsarArtifactsToHandle = null; - if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) { vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class); vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value()); } else { - Either>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle( - component, artifactPathAndNameList.left().value(), csarInfo.getModifier()); + Either>, ResponseFormat> + findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle( + component, artifactPathAndNameList.left().value(), csarInfo.getModifier()); if (findVfCsarArtifactsToHandleRes.isRight()) { resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value()); } @@ -530,7 +1193,8 @@ public class ServiceImportBusinessLogic{ } } if (resStatus == null && vfCsarArtifactsToHandle != null) { - resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus, vfCsarArtifactsToHandle); + resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus, + vfCsarArtifactsToHandle); } if (resStatus == null) { resStatus = Either.left(component); @@ -545,27 +1209,22 @@ public class ServiceImportBusinessLogic{ } protected Either createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource, - List createdArtifacts, boolean shouldLock, boolean inTransaction, - ArtifactOperationInfo artifactOperation) { + List createdArtifacts, boolean shouldLock, + boolean inTransaction, ArtifactOperationInfo artifactOperation) { return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation); } - protected Either processCsarArtifacts(CsarInfo csarInfo, Component comp, List createdArtifacts, boolean shouldLock, boolean inTransaction, - Either resStatus, EnumMap> vfCsarArtifactsToHandle) { + protected Either processCsarArtifacts(CsarInfo csarInfo, Component comp, + List createdArtifacts, boolean shouldLock, + boolean inTransaction, Either resStatus, + EnumMap> vfCsarArtifactsToHandle) { for (Map.Entry> currArtifactOperationPair : vfCsarArtifactsToHandle - .entrySet()) { - Optional optionalCreateInDBError = - currArtifactOperationPair.getValue().stream() - .map(e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), - e.getArtifactName(), e.getArtifactType(), - e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), - CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(), - new ArtifactOperationInfo(false, false, - currArtifactOperationPair.getKey()), - createdArtifacts, e.isFromCsar(), shouldLock, inTransaction)) - .filter(Either::isRight). - map(e -> e.right().value()). - findAny(); + .entrySet()) { + Optional optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map( + e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(), + e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(), + new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock, + inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny(); if (optionalCreateInDBError.isPresent()) { resStatus = Either.right(optionalCreateInDBError.get()); break; @@ -574,54 +1233,53 @@ public class ServiceImportBusinessLogic{ return resStatus; } - protected Either createOrUpdateSingleNonMetaArtifact(Component component, 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) { + protected Either createOrUpdateSingleNonMetaArtifact(Component component, 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() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) { + if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE + || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) { if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) { - Either handleDelete = serviceBusinessLogic.artifactsBusinessLogic.handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, - shouldLock, inTransaction); + Either handleDelete = artifactsBusinessLogic + .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction); if (handleDelete.isRight()) { result = Either.right(handleDelete.right().value()); } return result; } if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) { - operation = new ArtifactOperationInfo(false, false, - ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE); + operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE); } } if (artifactFileBytes != null) { Map vendorLicenseModelJson = ArtifactUtils - .buildJsonForUpdateArtifact(artifactId, artifactFileName, - artifactType, artifactGroupType, artifactLabel, artifactDisplayName, artifactDescription, - artifactFileBytes, null, isFromCsar); - Either, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson( - component, csarInfo.getModifier(), vendorLicenseModelJson, operation); - serviceImportParseLogic - .addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts); + .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName, + artifactDescription, artifactFileBytes, null, isFromCsar); + Either, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic + .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation); + serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts); if (eitherNonMetaArtifacts.isRight()) { - BeEcompErrorManager.getInstance() - .logInternalFlowError("UploadLicenseArtifact", "Failed to upload license artifact: " - + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(), - BeEcompErrorManager.ErrorSeverity.WARNING); + BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact", + "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(), + BeEcompErrorManager.ErrorSeverity.WARNING); return Either.right(eitherNonMetaArtifacts.right().value()); } } return result; } - public Either, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource, - Map> nodeTypeArtifactsToHandle, - List createdArtifacts, User user, boolean inTransaction, boolean ignoreLifecycleState) { + private Either, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource, + Map> nodeTypeArtifactsToHandle, + List createdArtifacts, User user, + boolean inTransaction, boolean ignoreLifecycleState) { List handleNodeTypeArtifactsRequestRes; Either, ResponseFormat> handleNodeTypeArtifactsRes = null; Either changeStateResponse; @@ -631,30 +1289,24 @@ public class ServiceImportBusinessLogic{ 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 (Map.Entry> curOperationEntry : nodeTypeArtifactsToHandle - .entrySet()) { + .entrySet()) { ArtifactsBusinessLogic.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 = serviceBusinessLogic.artifactsBusinessLogic - .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, - createdArtifacts, new ArtifactOperationInfo(false, - ignoreLifecycleState, curOperation), - false, inTransaction); + log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName()); + handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic + .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts, + new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction); if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) { createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes); } handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes); } } - if (handleNodeTypeArtifactsRes == null) { - handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts); - } + handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts); } catch (Exception e) { ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR); handleNodeTypeArtifactsRes = Either.right(responseFormat); @@ -663,16 +1315,15 @@ public class ServiceImportBusinessLogic{ return handleNodeTypeArtifactsRes; } - protected Either checkoutResource(Resource resource, User user, boolean inTransaction) { + private Either checkoutResource(Resource resource, User user, boolean inTransaction) { Either checkoutResourceRes; try { if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState() - .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { - Either checkoutRes = lifecycleBusinessLogic.changeComponentState( - resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT, + .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { + Either checkoutRes = lifecycleBusinessLogic + .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT, new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT, - LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), - inTransaction, true); + LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true); if (checkoutRes.isRight()) { checkoutResourceRes = Either.right(checkoutRes.right().value()); } else { @@ -684,35 +1335,26 @@ public class ServiceImportBusinessLogic{ } 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); + log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e); } return checkoutResourceRes; } - protected Either createOrUpdateArtifacts( - ArtifactsBusinessLogic.ArtifactOperationEnum operation, List createdArtifacts, - String yamlFileName, CsarInfo csarInfo, Service preparedService, - NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts, boolean inTransaction, boolean shouldLock) { - - Service resource = preparedService; - Map>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts - .getNodeTypesArtifactsToHandle(); - + protected Either createOrUpdateArtifacts(ArtifactOperationEnum operation, List createdArtifacts, + String yamlFileName, CsarInfo csarInfo, Service preparedService, + boolean inTransaction, boolean shouldLock) { Either createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts, - new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction); + 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); + return Either.left(createdCsarArtifactsEither.left().value()); } - protected Either handleVfCsarArtifacts(Service service, CsarInfo csarInfo, - List createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock, - boolean inTransaction) { - + protected Either handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List createdArtifacts, + ArtifactOperationInfo artifactOperation, boolean shouldLock, + boolean inTransaction) { if (csarInfo.getCsar() != null) { String vendorLicenseModelId = null; String vfLicenseModelId = null; @@ -729,41 +1371,40 @@ public class ServiceImportBusinessLogic{ } } } - createOrUpdateSingleNonMetaArtifact(service, 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, true, shouldLock, - inTransaction); - createOrUpdateSingleNonMetaArtifact(service, 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, true, shouldLock, inTransaction); - - Either eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, - createdArtifacts, shouldLock, inTransaction, artifactOperation); + createOrUpdateSingleNonMetaArtifact(service, 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, true, shouldLock, inTransaction); + createOrUpdateSingleNonMetaArtifact(service, 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, true, shouldLock, + inTransaction); + Either eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock, + inTransaction, artifactOperation); if (eitherCreateResult.isRight()) { return Either.right(eitherCreateResult.right().value()); } - Either eitherGerResource = toscaOperationFacade - .getToscaElement(service.getUniqueId()); + Either eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId()); if (eitherGerResource.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service, ComponentTypeEnum.SERVICE); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service, + ComponentTypeEnum.SERVICE); return Either.right(responseFormat); } service = eitherGerResource.left().value(); - Either, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils.getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils); - + 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 (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) { - createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts); + createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic + .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts); } else { - Either result = csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock, inTransaction); + Either result = csarArtifactsAndGroupsBusinessLogic + .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock, + inTransaction); if ((result.left().value() instanceof Service) && result.isLeft()) { Service service1 = (Service) result.left().value(); createArtifactsFromCsar = Either.left(service1); @@ -784,13 +1425,13 @@ public class ServiceImportBusinessLogic{ } protected Either createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource, - List createdArtifacts, boolean shouldLock, boolean inTransaction, - ArtifactOperationInfo artifactOperation) { + List createdArtifacts, boolean shouldLock, + boolean inTransaction, ArtifactOperationInfo artifactOperation) { return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation); } protected Either>, ResponseFormat> findVfCsarArtifactsToHandle( - Component component, List artifactPathAndNameList, User user) { + Component component, List artifactPathAndNameList, User user) { List existingArtifacts = new ArrayList<>(); if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) { existingArtifacts.addAll(component.getDeploymentArtifacts().values()); @@ -799,7 +1440,6 @@ public class ServiceImportBusinessLogic{ existingArtifacts.addAll(component.getArtifacts().values()); } existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList()); - List artifactsToIgnore = new ArrayList<>(); if (component.getGroups() != null) { component.getGroups().forEach(g -> { @@ -808,12 +1448,11 @@ public class ServiceImportBusinessLogic{ } }); } - existingArtifacts = existingArtifacts.stream() - .filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList()); + existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList()); return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user); } - protected boolean isNonMetaArtifact(ArtifactDefinition artifact) { + private boolean isNonMetaArtifact(ArtifactDefinition artifact) { boolean result = true; if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) { result = false; @@ -822,36 +1461,32 @@ public class ServiceImportBusinessLogic{ } private boolean isValidArtifactType(ArtifactDefinition artifact) { - boolean result = true; - if (artifact.getArtifactType() == null - || ArtifactTypeEnum.findType(artifact.getArtifactType()).equals(ArtifactTypeEnum.VENDOR_LICENSE) - || ArtifactTypeEnum.findType(artifact.getArtifactType()).equals(ArtifactTypeEnum.VF_LICENSE)) { - result = false; - } - return result; + final String artifactType = artifact.getArtifactType(); + return artifactType != null + && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType)) + && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType)); } + protected Either>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation( - List artifactPathAndNameList, List existingArtifactsToHandle, - Component component, User user) { + List artifactPathAndNameList, List existingArtifactsToHandle, Component component, + User user) { EnumMap> nodeTypeArtifactsToHandle = new EnumMap<>( - ArtifactsBusinessLogic.ArtifactOperationEnum.class); + ArtifactsBusinessLogic.ArtifactOperationEnum.class); Wrapper responseWrapper = new Wrapper<>(); - Either>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either - .left(nodeTypeArtifactsToHandle); + Either>, ResponseFormat> + nodeTypeArtifactsToHandleRes = Either + .left(nodeTypeArtifactsToHandle); try { List artifactsToUpload = new ArrayList<>(artifactPathAndNameList); List artifactsToUpdate = new ArrayList<>(); List artifactsToDelete = new ArrayList<>(); for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) { ArtifactDefinition foundArtifact; - if (!existingArtifactsToHandle.isEmpty()) { - foundArtifact = existingArtifactsToHandle.stream() - .filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName())).findFirst() - .orElse(null); + foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName())) + .findFirst().orElse(null); if (foundArtifact != null) { - if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact - .getArtifactType())) { + if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) { if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) { currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId()); artifactsToUpdate.add(currNewArtifact); @@ -859,18 +1494,15 @@ public class ServiceImportBusinessLogic{ existingArtifactsToHandle.remove(foundArtifact); artifactsToUpload.remove(currNewArtifact); } else { - log.debug("Can't upload two artifact with the same name {}.", - currNewArtifact.getArtifactName()); - ResponseFormat responseFormat = ResponseFormatManager.getInstance().getResponseFormat( - ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, - currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(), - foundArtifact.getArtifactType()); - AuditingActionEnum auditingAction = serviceBusinessLogic.artifactsBusinessLogic - .detectAuditingType(new ArtifactOperationInfo(false, false, - ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE), foundArtifact.getArtifactChecksum()); - serviceBusinessLogic.artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), - user, null, null, foundArtifact.getUniqueId(), responseFormat, - component.getComponentType(), null); + log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName()); + ResponseFormat responseFormat = ResponseFormatManager.getInstance() + .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(), + currNewArtifact.getArtifactType(), foundArtifact.getArtifactType()); + AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType( + new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE), + foundArtifact.getArtifactChecksum()); + artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null, + foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null); responseWrapper.setInnerElement(responseFormat); break; } @@ -880,9 +1512,13 @@ public class ServiceImportBusinessLogic{ if (responseWrapper.isEmpty()) { for (ArtifactDefinition currArtifact : existingArtifactsToHandle) { if (currArtifact.getIsFromCsar()) { - artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null, ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); + artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null, + ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, + currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); } else { - artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null, ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); + artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null, + ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null, + currArtifact.getUniqueId(), currArtifact.getIsFromCsar())); } } } @@ -909,25 +1545,12 @@ public class ServiceImportBusinessLogic{ return nodeTypeArtifactsToHandleRes; } - - public ComponentsUtils getComponentsUtils() { - return this.componentsUtils; - } - - public void setComponentsUtils(ComponentsUtils componentsUtils) { - this.componentsUtils = componentsUtils; - } - - protected Either, String> getValidArtifactNames(CsarInfo csarInfo, Map>> collectedWarningMessages) { - List artifactPathAndNameList = - csarInfo.getCsar().entrySet().stream() - .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()) - .matches()) - .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), - collectedWarningMessages)) - .filter(Either::isLeft) - .map(e -> e.left().value()) - .collect(toList()); + protected Either, String> getValidArtifactNames(CsarInfo csarInfo, + Map>> collectedWarningMessages) { + List artifactPathAndNameList = csarInfo.getCsar().entrySet().stream() + .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches()) + .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft) + .map(e -> e.left().value()).collect(toList()); Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME); for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) { if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) { @@ -937,25 +1560,51 @@ public class ServiceImportBusinessLogic{ return Either.left(artifactPathAndNameList); } - protected Either createGroupsOnResource(Service service, - Map groups) { + protected Either createGroupsOnResource(Service service, Map groups) { if (groups != null && !groups.isEmpty()) { List groupsAsList = updateGroupsMembersUsingResource(groups, service); serviceImportParseLogic.handleGroupsProperties(service, groups); serviceImportParseLogic.fillGroupsFinalFields(groupsAsList); - Either, ResponseFormat> createGroups = serviceBusinessLogic.groupBusinessLogic.createGroups(service, - groupsAsList, true); + Either, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true); if (createGroups.isRight()) { return Either.right(createGroups.right().value()); } } else { return Either.left(service); } - Either updatedResource = toscaOperationFacade - .getToscaElement(service.getUniqueId()); + return getServiceResponseFormatEither(service); + } + + private Either createPoliciesOnResource(final Service service, + final Map policies) { + if (MapUtils.isEmpty(policies)) { + return Either.left(service); + } + Map> componentInstancesAttributes = service.getComponentInstancesAttributes(); + final Map> instanceAttributeMap = new HashMap<>(); + if (MapUtils.isNotEmpty(componentInstancesAttributes)) { + instanceAttributeMap.putAll(componentInstancesAttributes + .entrySet().stream() + .collect(toMap(Entry::getKey, entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList())))); + } + policies.values().stream() + .map(PolicyDataDefinition::getProperties) + .flatMap(Collection::stream) + .filter(PropertyDataDefinition::isToscaFunction) + .forEach(policyDefinition -> toscaFunctionService + .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(), + instanceAttributeMap) + ); + policyBusinessLogic.createPolicies(service, policies); + return getServiceResponseFormatEither(service); + } + + private Either getServiceResponseFormatEither(Service service) { + Either updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId()); if (updatedResource.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service, ComponentTypeEnum.SERVICE); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service, + ComponentTypeEnum.SERVICE); return Either.right(responseFormat); } return Either.left(updatedResource.left().value()); @@ -965,10 +1614,6 @@ public class ServiceImportBusinessLogic{ List result = new ArrayList<>(); List componentInstances = component.getComponentInstances(); if (groups != null) { - Either validateCyclicGroupsDependencies = serviceImportParseLogic.validateCyclicGroupsDependencies(groups); - if (validateCyclicGroupsDependencies.isRight()) { - throw new ComponentException(validateCyclicGroupsDependencies.right().value()); - } for (Map.Entry entry : groups.entrySet()) { String groupName = entry.getKey(); GroupDefinition groupDefinition = entry.getValue(); @@ -976,8 +1621,7 @@ public class ServiceImportBusinessLogic{ updatedGroupDefinition.setMembers(null); Map members = groupDefinition.getMembers(); if (members != null) { - serviceImportParseLogic - .updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members); + serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members); } result.add(updatedGroupDefinition); } @@ -985,20 +1629,18 @@ public class ServiceImportBusinessLogic{ return result; } - protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource, - Map uploadComponentInstanceInfoMap, - String topologyTemplateYaml, List nodeTypesNewCreatedArtifacts, - Map nodeTypesInfo, CsarInfo csarInfo, - Map>> nodeTypesArtifactsToCreate, - String nodeName) { + Map uploadComponentInstanceInfoMap, + String topologyTemplateYaml, List nodeTypesNewCreatedArtifacts, + Map nodeTypesInfo, CsarInfo csarInfo, + Map>> nodeTypesArtifactsToCreate, + String nodeName) { try { log.debug("************* Going to create all nodes {}", yamlName); - handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, - nodeTypesInfo, csarInfo, nodeName); + handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo, + csarInfo, nodeName); log.debug("************* Going to create all resource instances {}", yamlName); - resource = createResourceInstances(yamlName, resource, - uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes()); + resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes()); log.debug("************* Finished to create all resource instances {}", yamlName); resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap); log.debug("************* Going to create positions {}", yamlName); @@ -1011,13 +1653,16 @@ public class ServiceImportBusinessLogic{ } protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource, - Map uploadResInstancesMap) { + Map uploadResInstancesMap) { log.debug("#createResourceInstancesRelations - Going to create relations "); List componentInstancesList = resource.getComponentInstances(); if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) && - resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances - log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ", resource.getUniqueId(), yamlName); - BeEcompErrorManager.getInstance().logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ", BeEcompErrorManager.ErrorSeverity.ERROR); + resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances + log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ", + resource.getUniqueId(), yamlName); + BeEcompErrorManager.getInstance() + .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ", + BeEcompErrorManager.ErrorSeverity.ERROR); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName)); } Map> instProperties = new HashMap<>(); @@ -1025,63 +1670,58 @@ public class ServiceImportBusinessLogic{ Map>> instRequirements = new HashMap<>(); Map> instDeploymentArtifacts = new HashMap<>(); Map> instArtifacts = new HashMap<>(); - Map> instAttributes = new HashMap<>(); + Map> instAttributes = new HashMap<>(); Map originCompMap = new HashMap<>(); List relations = new ArrayList<>(); Map> instInputs = new HashMap<>(); - + Map instNodeFilter = new HashMap<>(); + Map> instInterfaces = new HashMap<>(); log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. "); - Either, JanusGraphOperationStatus> allDataTypes = serviceBusinessLogic.dataTypeCache.getAll(); - if (allDataTypes.isRight()) { - JanusGraphOperationStatus status = allDataTypes.right().value(); - BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", - "Failed to update property value on instance. Status is " + status, BeEcompErrorManager.ErrorSeverity.ERROR); - throw new ComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse( - DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)), yamlName)); - } - Resource finalResource = resource; - uploadResInstancesMap - .values() - .forEach(i -> processComponentInstance(yamlName, finalResource, componentInstancesList, allDataTypes, - instProperties, instCapabilities, instRequirements, instDeploymentArtifacts, - instArtifacts, instAttributes, originCompMap, instInputs, i)); + final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache; + if (applicationDataTypeCache != null) { + Resource finalResource = resource; + uploadResInstancesMap.values().forEach( + i -> processComponentInstance(yamlName, finalResource, componentInstancesList, + componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities, + instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, + instInterfaces, i)); + } serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties); serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs); - serviceImportParseLogic - .associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts); + serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts); serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts); serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements); serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes); resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource); - - serviceImportParseLogic - .addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations); + serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations); serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations); handleSubstitutionMappings(resource, uploadResInstancesMap); log.debug("************* in create relations, getResource start"); Either eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId()); log.debug("************* in create relations, getResource end"); if (eitherGetResource.isRight()) { - throw new ComponentException(componentsUtils.getResponseFormatByResource( - componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource)); + throw new ComponentException( + componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource)); } return eitherGetResource.left().value(); } - protected void processProperty(Resource resource, ComponentInstance currentCompInstance, Map allDataTypes, Map currPropertiesMap, List instPropList, List propertyList) { + protected void processProperty(Resource resource, Map allDataTypes, + Map currPropertiesMap, List instPropList, + List propertyList) { UploadPropInfo propertyInfo = propertyList.get(0); String propName = propertyInfo.getName(); if (!currPropertiesMap.containsKey(propName)) { - throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, - propName)); + throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName)); } processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs()); } - private void processProperty(Map allDataTypes, Map currPropertiesMap, List instPropList, UploadPropInfo propertyInfo, String propName, List inputs2) { + private void processProperty(Map allDataTypes, Map currPropertiesMap, + List instPropList, UploadPropInfo propertyInfo, String propName, + List inputs2) { InputDefinition curPropertyDef = currPropertiesMap.get(propName); ComponentInstanceInput property = null; - String value = null; List getInputs = null; boolean isValidate = true; @@ -1089,17 +1729,14 @@ public class ServiceImportBusinessLogic{ getInputs = propertyInfo.getGet_input(); isValidate = getInputs == null || getInputs.isEmpty(); if (isValidate) { - value = getPropertyJsonStringValue(propertyInfo.getValue(), - curPropertyDef.getType()); + value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType()); } else { - value = getPropertyJsonStringValue(propertyInfo.getValue(), - TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); + value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); } } property = new ComponentInstanceInput(curPropertyDef, value, null); String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes); property.setValue(validPropertyVAlue); - if (isNotEmpty(getInputs)) { List getInputValues = new ArrayList<>(); for (GetInputValueDataDefinition getInput : getInputs) { @@ -1107,16 +1744,13 @@ public class ServiceImportBusinessLogic{ if (CollectionUtils.isEmpty(inputs)) { throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)); } - - Optional optional = inputs.stream() - .filter(p -> p.getName().equals(getInput.getInputName())).findAny(); + Optional optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny(); if (!optional.isPresent()) { throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)); } InputDefinition input = optional.get(); getInput.setInputId(input.getUniqueId()); getInputValues.add(getInput); - GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex(); processGetInput(getInputValues, inputs, getInputIndex); } @@ -1130,23 +1764,21 @@ public class ServiceImportBusinessLogic{ if (resource.getResourceType() == ResourceTypeEnum.VF) { Either getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId()); if (getResourceRes.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( - componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource); throw new ComponentException(responseFormat); } - getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), - uploadResInstancesMap); + getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap); if (getResourceRes.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( - componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource); throw new ComponentException(responseFormat); } } } - protected Resource createResourceInstances(String yamlName, Resource resource, - Map uploadResInstancesMap, - Map nodeNamespaceMap) { + protected Resource createResourceInstances(String yamlName, Resource resource, Map uploadResInstancesMap, + Map nodeNamespaceMap) { Either eitherResource = null; log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName); if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances @@ -1158,19 +1790,16 @@ public class ServiceImportBusinessLogic{ nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v)); } Map resourcesInstancesMap = new HashMap<>(); - uploadResInstancesMap - .values() - .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap)); - + uploadResInstancesMap.values() + .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap)); if (MapUtils.isNotEmpty(resourcesInstancesMap)) { try { - toscaOperationFacade.associateComponentInstancesToComponent(resource, - resourcesInstancesMap, false, false); + toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false); } catch (StorageException exp) { if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) { log.debug("Failed to add component instances to container component {}", resource.getName()); ResponseFormat responseFormat = componentsUtils - .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus())); + .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus())); eitherResource = Either.right(responseFormat); throw new ByResponseFormatComponentException(eitherResource.right().value()); } @@ -1178,181 +1807,174 @@ public class ServiceImportBusinessLogic{ } log.debug("*************Going to get resource {}", resource.getUniqueId()); Either eitherGetResource = toscaOperationFacade - .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter()); + .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter()); log.debug("*************finished to get resource {}", resource.getUniqueId()); if (eitherGetResource.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( - componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource); throw new ComponentException(responseFormat); } if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) && - resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances + resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances log.debug("Error when create resource instance from csar. ComponentInstances list empty"); - BeEcompErrorManager.getInstance().logBeDaoSystemError( - "Error when create resource instance from csar. ComponentInstances list empty"); + BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty"); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE)); } return eitherGetResource.left().value(); } - protected void handleNodeTypes(String yamlName, Resource resource, - String topologyTemplateYaml, boolean needLock, - Map>> nodeTypesArtifactsToHandle, - List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, - CsarInfo csarInfo, String nodeName) { + protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, + String nodeName) { try { for (Map.Entry nodeTypeEntry : nodeTypesInfo.entrySet()) { if (nodeTypeEntry.getValue().isNested()) { - - handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, - nodeTypesInfo, csarInfo, nodeTypeEntry.getKey()); + handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, + nodeTypeEntry.getKey()); log.trace("************* finished to create node {}", nodeTypeEntry.getKey()); } } Map mappedToscaTemplate = null; - if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) - && nodeTypesInfo.containsKey(nodeName)) { + if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo + .containsKey(nodeName)) { mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate(); } if (MapUtils.isEmpty(mappedToscaTemplate)) { mappedToscaTemplate = (Map) new Yaml().load(topologyTemplateYaml); } createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle, - nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo); + nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo); } catch (ComponentException e) { - ResponseFormat responseFormat = e.getResponseFormat() != null ? e.getResponseFormat() - : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()); + ResponseFormat responseFormat = + e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); throw e; } catch (StorageException e) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); throw e; - }catch (Exception e){ + } catch (Exception e) { log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected Resource handleNestedVfc(Service service, Map>> nodesArtifactsToHandle, + protected Resource handleNestedVfc(Service service, + Map>> nodesArtifactsToHandle, List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName) { try { String yamlName = nodesInfo.get(nodeName).getTemplateFileName(); Map nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate(); - createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, - nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo); + createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo, + csarInfo); log.debug("************* Finished to create node types from yaml {}", yamlName); if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) { log.debug("************* Going to handle complex VFC from yaml {}", yamlName); - Resource resource = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, - csarInfo, nodeName, yamlName); - return resource; + return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName); } return new Resource(); - } catch (Exception e) { + } catch (Exception e) { log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected Resource handleNestedVfc(Resource resource, Map>> nodesArtifactsToHandle, - List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, - String nodeName) { + protected Resource handleNestedVfc(Resource resource, + Map>> nodesArtifactsToHandle, + List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, + String nodeName) { String yamlName = nodesInfo.get(nodeName).getTemplateFileName(); Map nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate(); - log.debug("************* Going to create node types from yaml {}", yamlName); - createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, - nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo); - + createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo, + csarInfo); if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) { log.debug("************* Going to handle complex VFC from yaml {}", yamlName); - resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, - csarInfo, nodeName, yamlName); + resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName); } return resource; } - protected Resource handleComplexVfc(Resource resource, Map>> nodesArtifactsToHandle, - List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, - String nodeName, String yamlName) { + protected Resource handleComplexVfc(Resource resource, + Map>> nodesArtifactsToHandle, + List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, + String nodeName, String yamlName) { Resource oldComplexVfc = null; Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo); Either oldComplexVfcRes = toscaOperationFacade - .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName()); + .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName()); if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) { oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName( - serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), - nodeName).getRight()); + serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight()); } if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) { throw new ComponentException(ActionStatus.GENERAL_ERROR); } else if (oldComplexVfcRes.isLeft()) { log.debug(VALIDATE_DERIVED_BEFORE_UPDATE); - Either eitherValidation = serviceImportParseLogic.validateNestedDerivedFromDuringUpdate( - oldComplexVfcRes.left().value(), newComplexVfc, + Either eitherValidation = serviceImportParseLogic + .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc, ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion())); if (eitherValidation.isLeft()) { oldComplexVfc = oldComplexVfcRes.left().value(); } } - newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, - oldComplexVfc, newComplexVfc); + newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc, + newComplexVfc); csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName()); - LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction( - CERTIFICATION_ON_IMPORT, LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR); + LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT, + LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR); log.debug("Going to certify cvfc {}. ", newComplexVfc.getName()); final Resource result = serviceImportParseLogic - .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, - true); + .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true); csarInfo.getCreatedNodes().put(nodeName, result); csarInfo.removeNodeFromQueue(); return result; } - public Map createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map mappedToscaTemplate, boolean needLock, - Map>> nodeTypesArtifactsToHandle, - List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, - CsarInfo csarInfo) { + private Map createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map mappedToscaTemplate, + boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, + Map nodeTypesInfo, CsarInfo csarInfo) { Either toscaVersion = findFirstToscaStringElement(mappedToscaTemplate, - TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION); + TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION); if (toscaVersion.isRight()) { throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE); } Map mapToConvert = new HashMap<>(); mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value()); Map nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate); - createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert, nodeTypes); + createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert, + nodeTypes); return csarInfo.getCreatedNodes(); } - protected void createNodeTypes(String yamlName, Resource resource, boolean needLock, Map>> nodeTypesArtifactsToHandle, List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, Map mapToConvert, Map nodeTypes) { + protected void createNodeTypes(String yamlName, Resource resource, boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, + Map mapToConvert, Map nodeTypes) { Iterator> nodesNameValueIter = nodeTypes.entrySet().iterator(); Resource vfcCreated = null; while (nodesNameValueIter.hasNext()) { Map.Entry nodeType = nodesNameValueIter.next(); - Map> nodeTypeArtifactsToHandle = nodeTypesArtifactsToHandle == null - || nodeTypesArtifactsToHandle.isEmpty() ? null - : nodeTypesArtifactsToHandle.get(nodeType.getKey()); - + 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()); - vfcCreated = handleNestedVfc(resource, - nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, - nodeType.getKey()); + vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, + nodeType.getKey()); log.trace("************* Finished to handle nested vfc {}", nodeType.getKey()); - } else if (csarInfo.getCreatedNodesToscaResourceNames() != null - && !csarInfo.getCreatedNodesToscaResourceNames().containsKey(nodeType.getKey())) { + } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames() + .containsKey(nodeType.getKey())) { log.trace("************* Going to create node {}", nodeType.getKey()); - ImmutablePair resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, - resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, - csarInfo, true); + ImmutablePair resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), + mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true); log.debug("************* Finished to create node {}", nodeType.getKey()); - vfcCreated = resourceCreated.getLeft(); - csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), - vfcCreated.getToscaResourceName()); + csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName()); } if (vfcCreated != null) { csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated); @@ -1361,48 +1983,56 @@ public class ServiceImportBusinessLogic{ } } - protected ImmutablePair createNodeTypeResourceFromYaml( - String yamlName, Map.Entry nodeNameValue, User user, Map mapToConvert, - Resource resourceVf, boolean needLock, - Map> nodeTypeArtifactsToHandle, - List nodeTypesNewCreatedArtifacts, boolean forceCertificationAllowed, CsarInfo csarInfo, - boolean isNested) { - UploadResourceInfo resourceMetaData = serviceImportParseLogic - .fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), user); - - String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, - resourceMetaData.getResourceType(), csarInfo); - user = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true); - return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock, - nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, - nodeNameValue.getKey(), isNested); + protected ImmutablePair createNodeTypeResourceFromYaml(String yamlName, Map.Entry nodeNameValue, + User user, Map mapToConvert, Resource resourceVf, + boolean needLock, + Map> nodeTypeArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, + boolean forceCertificationAllowed, CsarInfo csarInfo, + boolean isNested) { + final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, + true); + UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), + validatedUser); + String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo); + return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock, + nodeTypeArtifactsToHandle, + nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested); } protected Service createRIAndRelationsFromYaml(String yamlName, Service service, - Map uploadComponentInstanceInfoMap, - String topologyTemplateYaml, List nodeTypesNewCreatedArtifacts, - Map nodeTypesInfo, CsarInfo csarInfo, - Map>> nodeTypesArtifactsToCreate, - String nodeName) { + Map uploadComponentInstanceInfoMap, + String topologyTemplateYaml, List nodeTypesNewCreatedArtifacts, + Map nodeTypesInfo, CsarInfo csarInfo, + Map>> nodeTypesArtifactsToCreate, + String nodeName) { log.debug("************* Going to create all nodes {}", yamlName); - handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName); - log.debug("************* Going to create all resource instances {}", yamlName); - service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes()); - log.debug("************* Going to create all relations {}", yamlName); - service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap); - log.debug("************* Going to create positions {}", yamlName); - compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId()); - log.debug("************* Finished to set positions {}", yamlName); + handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, + nodeTypesInfo, csarInfo, nodeName); + List serviceProperties = null != service ? service.getProperties() : Collections.emptyList(); + if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) { + log.debug("************* Going to create all resource instances {}", yamlName); + service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes()); + log.debug("************* Going to create all relations {}", yamlName); + service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap, serviceProperties); + log.debug("************* Going to create positions {}", yamlName); + compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId()); + log.debug("************* Finished to set positions {}", yamlName); + } return service; } protected Service createServiceInstancesRelations(User user, String yamlName, Service service, - Map uploadResInstancesMap) { + Map uploadResInstancesMap, + List serviceProperties) { log.debug("#createResourceInstancesRelations - Going to create relations "); List componentInstancesList = service.getComponentInstances(); - if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)))) { // PNF can have no resource instances - log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ", service.getUniqueId(), yamlName); - BeEcompErrorManager.getInstance().logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ", BeEcompErrorManager.ErrorSeverity.ERROR); + if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances + log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ", + service.getUniqueId(), yamlName); + BeEcompErrorManager.getInstance() + .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ", + BeEcompErrorManager.ErrorSeverity.ERROR); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName)); } Map> instProperties = new HashMap<>(); @@ -1410,91 +2040,113 @@ public class ServiceImportBusinessLogic{ Map>> instRequirements = new HashMap<>(); Map> instDeploymentArtifacts = new HashMap<>(); Map> instArtifacts = new HashMap<>(); - Map> instAttributes = new HashMap<>(); + Map> instAttributes = new HashMap<>(); Map originCompMap = new HashMap<>(); List relations = new ArrayList<>(); Map> instInputs = new HashMap<>(); - + Map instNodeFilter = new HashMap<>(); + Map> instInterfaces = new HashMap<>(); log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. "); - Either, JanusGraphOperationStatus> allDataTypes = serviceBusinessLogic.dataTypeCache.getAll(); - if (allDataTypes.isRight()) { - JanusGraphOperationStatus status = allDataTypes.right().value(); - BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", - "Failed to update property value on instance. Status is " + status, BeEcompErrorManager.ErrorSeverity.ERROR); - throw new ComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse( - DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)), yamlName)); - } - Service finalResource = service; - uploadResInstancesMap - .values() - .forEach(i -> processComponentInstance(yamlName, finalResource, componentInstancesList, allDataTypes, - instProperties, instCapabilities, instRequirements, instDeploymentArtifacts, - instArtifacts, instAttributes, originCompMap, instInputs, i)); + final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache; + if (applicationDataTypeCache != null) { + final Map allDataTypesMap = + componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel()); + final Service service1 = service; + service1.setProperties(serviceProperties); + uploadResInstancesMap.values().forEach( + i -> processComponentInstance(yamlName, service1, componentInstancesList, + allDataTypesMap, instProperties, + instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, + instNodeFilter, instInterfaces, i) + ); + } + updatePropertyToscaFunctionData(service, instProperties, instAttributes); serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties); + serviceImportParseLogic.associateComponentInstanceInterfacesToComponent( + yamlName, + service, + instInterfaces + ); serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs); + serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter); serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts); serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts); serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements); - log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", - instRequirements, instCapabilities); + log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities); serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes); ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service); Map capabilities = serviceTemplate.getCapabilities(); Map requirements = serviceTemplate.getRequirements(); - serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities); serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements); service = getResourceAfterCreateRelations(service); - addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations); serviceImportParseLogic.associateResourceInstances(yamlName, service, relations); - handleSubstitutionMappings(service, uploadResInstancesMap); log.debug("************* in create relations, getResource start"); Either eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId()); log.debug("************* in create relations, getResource end"); if (eitherGetResource.isRight()) { - throw new ComponentException(componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service, service.getComponentType())); + throw new ComponentException(componentsUtils + .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service, + service.getComponentType())); } return eitherGetResource.left().value(); } - protected void processComponentInstance(String yamlName, Component component, - List componentInstancesList, - Either, JanusGraphOperationStatus> allDataTypes, + private void updatePropertyToscaFunctionData(final Component service, + final Map> instancePropertyMap, + final Map> instanceAttributeMap) { + final Component updatedService = + toscaOperationFacade.getToscaElement(service.getUniqueId()).left() + .on(storageOperationStatus -> { + final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus); + final ResponseFormat responseFormat = + componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType()); + throw new ComponentException(responseFormat); + } + ); + instancePropertyMap.values().forEach(instancePropertyList -> + instancePropertyList.stream() + .filter(PropertyDataDefinition::isToscaFunction) + .forEach(instanceProperty -> { + toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(), + updatedService, instancePropertyMap, instanceAttributeMap); + instanceProperty.setValue(StringEscapeUtils.unescapeJava(instanceProperty.getToscaFunction().getValue())); + }) + ); + } + + protected void processComponentInstance(String yamlName, Component component, List componentInstancesList, + Map allDataTypes, Map> instProperties, Map>> instCapabilties, Map>> instRequirements, Map> instDeploymentArtifacts, Map> instArtifacts, - Map> instAttributes, - Map originCompMap, + Map> instAttributes, Map originCompMap, Map> instInputs, + Map instNodeFilter, + Map> instInterfaces, UploadComponentInstanceInfo uploadComponentInstanceInfo) { log.debug("enter ServiceImportBusinessLogic processComponentInstance"); Optional currentCompInstanceOpt = componentInstancesList.stream() - .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())) - .findFirst(); - if (!currentCompInstanceOpt.isPresent()) { - log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), - component.getUniqueId()); - BeEcompErrorManager.getInstance().logInternalDataError( - COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, - component.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); - ResponseFormat responseFormat = componentsUtils - .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); + .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst(); + if (currentCompInstanceOpt.isEmpty()) { + log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId()); + BeEcompErrorManager.getInstance() + .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(), + BeEcompErrorManager.ErrorSeverity.ERROR); + ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); throw new ComponentException(responseFormat); } ComponentInstance currentCompInstance = currentCompInstanceOpt.get(); String resourceInstanceId = currentCompInstance.getUniqueId(); Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance); - if (MapUtils.isNotEmpty(originResource.getRequirements())) { instRequirements.put(currentCompInstance, originResource.getRequirements()); } if (MapUtils.isNotEmpty(originResource.getCapabilities())) { - processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, - currentCompInstance, originResource); + processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource); } if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) { instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts()); @@ -1504,36 +2156,91 @@ public class ServiceImportBusinessLogic{ } if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) { instAttributes.put(resourceInstanceId, originResource.getAttributes()); + addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes()); + instAttributes.get(resourceInstanceId).addAll(addImplicitAttributeValues(originResource, uploadComponentInstanceInfo)); + } + if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() == null) { + instNodeFilter.put(resourceInstanceId, new UploadNodeFilterInfo()); + } else { + instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo()); + } + if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) { + + ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi( + uploadComponentInstanceInfo, + component, + originResource, + currentCompInstance, + instInterfaces + ); + if (addInterfacesToRiRes.getStatus() != 200) { + throw new ComponentException(addInterfacesToRiRes); + } } if (originResource.getResourceType() != ResourceTypeEnum.VF) { - ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, - originResource, currentCompInstance, instProperties, allDataTypes.left().value()); + ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource, + currentCompInstance, instProperties, allDataTypes); if (addPropertiesValueToRiRes.getStatus() != 200) { throw new ComponentException(addPropertiesValueToRiRes); } } else { - addInputsValuesToRi(uploadComponentInstanceInfo, component, - originResource, currentCompInstance, instInputs, allDataTypes.left().value()); + addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes); + } + } + + private List addImplicitAttributeValues(Resource originResource, UploadComponentInstanceInfo uploadComponentInstanceInfo) { + if (uploadComponentInstanceInfo.getAttributes() == null) { + return Collections.emptyList(); + } + List origAttributes = originResource.getAttributes().stream().map(AttributeDefinition::getName).collect(toList()); + Map uploadAttributes = uploadComponentInstanceInfo.getAttributes(); + List newAttributesToAdd = + uploadAttributes.keySet().stream().filter(newAttribute -> !origAttributes.contains(newAttribute)) + .collect(toList()); + List propsToAddAsAttributes = + originResource.getProperties().stream().filter(prop -> newAttributesToAdd.contains(prop.getName())).collect(toList()); + propsToAddAsAttributes.stream().forEach(prop -> { + Object value = uploadAttributes.get(prop.getName()).getValue(); + if (value instanceof Collection || value instanceof Map) { + Gson gson = new Gson(); + String json = gson.toJson(value); + prop.setValue(json); + } else { + prop.setValue(String.valueOf(value)); + } + }); + List attributesToAdd = new ArrayList<>(); + for (PropertyDefinition prop : propsToAddAsAttributes) { + attributesToAdd.add(getPropertyAsAttribute(prop)); } + return attributesToAdd; } + private AttributeDefinition getPropertyAsAttribute(PropertyDefinition property) { + AttributeDefinition attribute = new AttributeDefinition(); + attribute.setName(property.getName()); + attribute.setType(property.getType()); + attribute.setSchema(property.getSchema()); + attribute.setValue(property.getValue()); + attribute.setDefaultValue(property.getDefaultValue()); + return attribute; + } - protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, - Component component, Resource originResource, ComponentInstance currentCompInstance, - Map> instInputs, Map allDataTypes) { + protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource, + ComponentInstance currentCompInstance, Map> instInputs, + Map allDataTypes) { Map> propMap = uploadComponentInstanceInfo.getProperties(); try { if (MapUtils.isNotEmpty(propMap)) { Map currPropertiesMap = new HashMap<>(); List instPropList = new ArrayList<>(); - if (CollectionUtils.isEmpty(originResource.getInputs())) { log.debug("failed to find properties "); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND)); } originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p)); for (List propertyList : propMap.values()) { - processProperty(component, currentCompInstance, allDataTypes, currPropertiesMap, instPropList, propertyList); + processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList); } currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p))); instInputs.put(currentCompInstance.getUniqueId(), instPropList); @@ -1544,22 +2251,23 @@ public class ServiceImportBusinessLogic{ } } - protected void processProperty(Component component, ComponentInstance currentCompInstance, Map allDataTypes, Map currPropertiesMap, List instPropList, List propertyList) { + protected void processProperty(Component component, Map allDataTypes, + Map currPropertiesMap, List instPropList, + List propertyList) { UploadPropInfo propertyInfo = propertyList.get(0); String propName = propertyInfo.getName(); if (!currPropertiesMap.containsKey(propName)) { log.debug("failed to find property {} ", propName); - throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, - propName)); + throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName)); } processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs()); } - protected void processGetInput(List getInputValues, List inputs, GetInputValueDataDefinition getInputIndex) { + protected void processGetInput(List getInputValues, List inputs, + GetInputValueDataDefinition getInputIndex) { Optional optional; if (getInputIndex != null) { - optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())) - .findAny(); + optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny(); if (!optional.isPresent()) { log.debug("Failed to find input {} ", getInputIndex.getInputName()); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)); @@ -1570,73 +2278,98 @@ public class ServiceImportBusinessLogic{ } } - protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, - Component component, Resource originResource, ComponentInstance currentCompInstance, - Map> instProperties, Map allDataTypes) { + private void addAttributeValueToResourceInstance(Map> instAttributes, + Map attributeMap) { + if (attributeMap == null) { + return; + } + attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values() + .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> { + if (attributeValue.getValue() instanceof Collection || attributeValue.getValue() instanceof Map) { + Gson gson = new Gson(); + String json = gson.toJson(attributeValue.getValue()); + attr.setValue(json); + } else { + attr.setValue(String.valueOf(attributeValue.getValue())); + } + }))); + } + + protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, + Resource originResource, ComponentInstance currentCompInstance, + 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())) { + List originalPropertyList = originResource.getProperties(); + if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) { log.debug("failed to find properties "); return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND); } - if (listFromMap == null || listFromMap.isEmpty()) { + if (CollectionUtils.isEmpty(originalPropertyList)) { return componentsUtils.getResponseFormat(ActionStatus.OK); } - for (PropertyDefinition prop : listFromMap) { - String propName = prop.getName(); - if (!currPropertiesMap.containsKey(propName)) { - currPropertiesMap.put(propName, prop); - } - } + originalPropertyList.stream() + .filter(property -> !currPropertiesMap.containsKey(property.getName())) + .forEach(property -> currPropertiesMap.put(property.getName(), property)); List instPropList = new ArrayList<>(); - if (propMap != null && propMap.size() > 0) { - for (List propertyList : propMap.values()) { + if (MapUtils.isNotEmpty(propMap)) { + for (final List propertyList : propMap.values()) { UploadPropInfo propertyInfo = propertyList.get(0); String propName = propertyInfo.getName(); if (!currPropertiesMap.containsKey(propName)) { log.debug("failed to find property {} ", propName); - return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, - propName); + return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName); } PropertyDefinition curPropertyDef = currPropertiesMap.get(propName); - ComponentInstanceProperty property = null; - String value = null; - List getInputs = null; + final List getInputs = new ArrayList<>(); boolean isValidate = true; if (propertyInfo.getValue() != null) { - getInputs = propertyInfo.getGet_input(); - isValidate = getInputs == null || getInputs.isEmpty(); + getInputs.addAll(propertyInfo.getGet_input()); + isValidate = getInputs.isEmpty(); if (isValidate) { - value = getPropertyJsonStringValue(propertyInfo.getValue(), - curPropertyDef.getType()); + value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType()); } else { - value = getPropertyJsonStringValue(propertyInfo.getValue(), - TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); + value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); } } - property = new ComponentInstanceProperty(curPropertyDef, value, null); + final var property = new ComponentInstanceProperty(curPropertyDef, value, null); + String validatedPropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, true, allDataTypes); + + addSubPropertyYamlToscaFunctions(validatedPropValue, value, property.getType(), propertyInfo, allDataTypes); - String validatePropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes); - property.setValue(validatePropValue); + if (CollectionUtils.isNotEmpty(propertyInfo.getSubPropertyToscaFunctions())) { + validatedPropValue = value; + } - if (getInputs != null && !getInputs.isEmpty()) { - List getInputValues = new ArrayList<>(); - for (GetInputValueDataDefinition getInput : getInputs) { - List inputs = component.getInputs(); + property.setValue(validatedPropValue); + + if (tryHandlingAsYamlToscaFunction(validatedPropValue, value, propertyInfo)) { + try { + final Object yamlValue = new Yaml().loadAs(value, Object.class); + CustomYamlFunction toscaFunction = new CustomYamlFunction(); + toscaFunction.setYamlValue(yamlValue); + property.setToscaFunction(toscaFunction); + } catch (Exception exception) { + log.info("Cannot create YAML value for {}", propName); + } + } else { + property.setToscaFunction(propertyInfo.getToscaFunction()); + } + property.setSubPropertyToscaFunctions(propertyInfo.getSubPropertyToscaFunctions()); + if (!getInputs.isEmpty() && CollectionUtils.isEmpty(property.getSubPropertyToscaFunctions())) { + final List getInputValues = new ArrayList<>(); + for (final GetInputValueDataDefinition getInput : getInputs) { + final List inputs = component.getInputs(); if (inputs == null || inputs.isEmpty()) { log.debug("Failed to add property {} to instance. Inputs list is empty ", property); - serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, property.getGetInputValues() - .stream() - .map(GetInputValueDataDefinition::getInputName) - .collect(toList()).toString()); + serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, + property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString()); } InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput); getInput.setInputId(input.getUniqueId()); getInputValues.add(getInput); - GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex(); if (getInputIndex != null) { input = serviceImportParseLogic.findInputByName(inputs, getInputIndex); @@ -1659,16 +2392,203 @@ public class ServiceImportBusinessLogic{ return componentsUtils.getResponseFormat(ActionStatus.OK); } - protected void processComponentInstanceCapabilities(Either, JanusGraphOperationStatus> allDataTypes, Map>> instCapabilties, UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance, Resource originResource) { + private boolean tryHandlingAsYamlToscaFunction(String validatedPropValue, String value, UploadPropInfo propertyInfo) { + return StringUtils.isEmpty(validatedPropValue) && StringUtils.isNotEmpty(value) && propertyInfo.getToscaFunction() == null + && CollectionUtils.isEmpty(propertyInfo.getSubPropertyToscaFunctions()); + } + + private void addSubPropertyYamlToscaFunctions(final String validatedPropValue, final String value, final String propertyType, + final UploadPropInfo propertyInfo, final Map allDataTypes) { + if (StringUtils.isNotEmpty(validatedPropValue) || StringUtils.isEmpty(value) || ToscaPropertyType.isValidType(propertyType) != null) { + return; + } + try { + final JsonObject jsonObject = JsonParser.parseString(value).getAsJsonObject(); + + final DataTypeDefinition dataTypeDefinition = allDataTypes.get(propertyType); + final List propertyNames = + dataTypeDefinition.getProperties().stream().map(PropertyDataDefinition::getName).collect(Collectors.toList()); + + boolean hasSubPropertyValues = jsonObject.entrySet().stream().allMatch(entry -> propertyNames.contains(entry.getKey())); + + if (hasSubPropertyValues) { + for (final PropertyDefinition prop : dataTypeDefinition.getProperties()) { + if (propertyInfo.getSubPropertyToscaFunctions().stream() + .anyMatch(subPropertyToscaFunction -> subPropertyToscaFunction.getSubPropertyPath().get(0).equals(prop.getName()))) { + continue; + } + Optional subPropertyToscaFunction = createSubPropertyYamlToscaFunction(jsonObject, prop, allDataTypes); + if (subPropertyToscaFunction.isPresent()) { + propertyInfo.getSubPropertyToscaFunctions().add(subPropertyToscaFunction.get()); + } + } + } + } catch (Exception exception) { + log.info("Cannot create YAML value for {}", value); + } + } + + private Optional createSubPropertyYamlToscaFunction(final JsonObject jsonObject, final PropertyDefinition prop, + final Map allDataTypes) { + JsonElement propJsonElement = jsonObject.get(prop.getName()); + if (propJsonElement != null) { + final String subPropValue = propJsonElement.toString(); + final ComponentInstanceProperty subProperty = new ComponentInstanceProperty(prop, subPropValue, null); + final String validateSubPropValue = + serviceBusinessLogic.validatePropValueBeforeCreate(subProperty, subPropValue, true, allDataTypes); + + if (StringUtils.isEmpty(validateSubPropValue) && StringUtils.isNotEmpty(subPropValue)) { + try { + Object yamlValue = new Yaml().loadAs(subPropValue, Object.class); + SubPropertyToscaFunction subPropertyToscaFunction = new SubPropertyToscaFunction(); + CustomYamlFunction toscaFunction = new CustomYamlFunction(); + toscaFunction.setYamlValue(yamlValue); + subPropertyToscaFunction.setToscaFunction(toscaFunction); + subPropertyToscaFunction.setSubPropertyPath(Collections.singletonList(prop.getName())); + return Optional.of(subPropertyToscaFunction); + } catch (Exception exception) { + log.info("Cannot create YAML value for {}", subPropValue); + } + } + } + return Optional.empty(); + } + + protected ResponseFormat addInterfaceValuesToRi( + UploadComponentInstanceInfo uploadComponentInstanceInfo, + Component component, + Resource originResource, ComponentInstance currentCompInstance, + Map> instInterfaces + ) { + Map instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces(); + Map currInterfacesMap = new HashMap<>(); + Map interfacesFromNodeType = originResource.getInterfaces(); + if (interfacesFromNodeType == null) { + interfacesFromNodeType = new HashMap<>(); + } + if (MapUtils.isEmpty(instanceInterfacesMap) && MapUtils.isEmpty(instanceInterfacesMap)) { + log.debug("failed to find interfaces "); + return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT); + } + for (Map.Entry entryInstances : interfacesFromNodeType.entrySet()) { + String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1); + if (!currInterfacesMap.containsKey(interfaceName)) { + currInterfacesMap.put(interfaceName, entryInstances.getValue()); + } + } + + Map instInterfacesMap = new HashMap<>(); + if (MapUtils.isNotEmpty(instanceInterfacesMap)) { + for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) { + String interfaceName = uploadInterfaceInfo.getName(); + InterfaceDefinition currentInterfaceDef; + if (!currInterfacesMap.containsKey(interfaceName)) { + currentInterfaceDef = getInterfaceDef(interfaceName, component.getModel()); + if (currentInterfaceDef == null) { + log.debug("failed to find interface {} ", interfaceName); + return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName); + } + } else { + currentInterfaceDef = currInterfacesMap.get(interfaceName); + } + Map operationsToAdd = new HashMap<>(); + + Map operations = uploadInterfaceInfo.getOperations(); + for (Map.Entry operation : operations.entrySet()) { + OperationDataDefinition instanceOperation = operation.getValue(); + OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap() + .getOrDefault(operation.getKey(), new Operation(instanceOperation)); + //Inputs + ListDataDefinition instanceInputs = instanceOperation.getInputs(); + if (null != instanceInputs) { + mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs); + component.getProperties() + .forEach(property -> instanceInputs.getListToscaDataDefinition().stream() + .filter(instanceInput -> + instanceInput.getToscaFunction() instanceof ToscaGetFunctionDataDefinition && + property.getName().equals(instanceInput.getToscaFunction() != null ? + ((ToscaGetFunctionDataDefinition) instanceInput.getToscaFunction()).getPropertyName() : null)) + .forEach(oldInput -> oldInput.setType(property.getType())) + ); + templateOperation.setInputs(instanceInputs); + } + //Implementation + templateOperation.setImplementation(instanceOperation.getImplementation()); + //Description + templateOperation.setDescription(instanceOperation.getDescription()); + templateOperation.setMilestones(instanceOperation.getMilestones()); + operationsToAdd.put(operation.getKey(), templateOperation); + } + InterfaceDefinition interfaceDef = new InterfaceDefinition(); + interfaceDef.setModel(component.getModel()); + interfaceDef.setType(currentInterfaceDef.getType()); + interfaceDef.setUniqueId(currentInterfaceDef.getType()); + interfaceDef.setDescription(uploadInterfaceInfo.getDescription()); + interfaceDef.setOperations(operationsToAdd); + instInterfacesMap.put(currentInterfaceDef.getType(), interfaceDef); + currInterfacesMap.remove(interfaceName); + } + } + if (!currInterfacesMap.isEmpty()) { + for (InterfaceDefinition value : currInterfacesMap.values()) { + instInterfacesMap.put(value.getUniqueId(), value); + } + } + instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap); + return componentsUtils.getResponseFormat(ActionStatus.OK); + } + + private InterfaceDefinition getInterfaceDef(String interfaceName, String model) { + Either, StorageOperationStatus> interfaceLifecycleTypesEither = + interfaceLifecycleTypeOperation.getAllInterfaceLifecycleTypes(model); + if (interfaceLifecycleTypesEither.isRight()) { + return null; + } + Map interfaceLifecycleTypes = interfaceLifecycleTypesEither.left().value(); + Optional interfaceType = + interfaceLifecycleTypes.values().stream().filter(interfaceDef -> interfaceDef.getUniqueId().contains(interfaceName)).findFirst(); + if (interfaceType.isEmpty()) { + return null; + } + return interfaceType.get(); + } + + private void mergeOperationInputDefinitions(ListDataDefinition inputsFromNodeType, + ListDataDefinition instanceInputs) { + if (inputsFromNodeType == null || CollectionUtils.isEmpty(inputsFromNodeType.getListToscaDataDefinition()) || instanceInputs == null + || CollectionUtils.isEmpty(instanceInputs.getListToscaDataDefinition())) { + return; + } + instanceInputs.getListToscaDataDefinition().forEach( + instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter( + templateInput -> templateInput.getName().equals(instanceInput.getName()) + ).forEach( + newInstanceInput -> { + instanceInput.setSourceProperty(newInstanceInput.getSourceProperty()); + instanceInput.setSource(newInstanceInput.getSource()); + instanceInput.setType(newInstanceInput.getType()); + } + ) + ); + instanceInputs.getListToscaDataDefinition().stream() + .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch( + inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName()) + )) + .forEach(oldInput -> oldInput.setType("string")); + } + + protected void processComponentInstanceCapabilities(Map allDataTypes, + Map>> instCapabilties, + UploadComponentInstanceInfo uploadComponentInstanceInfo, + ComponentInstance currentCompInstance, Resource originResource) { log.debug("enter processComponentInstanceCapabilities"); Map> originCapabilities; if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) { originCapabilities = new HashMap<>(); Map> newPropertiesMap = new HashMap<>(); - originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic - .addCapabilities(originCapabilities, k, v)); - uploadComponentInstanceInfo.getCapabilities().values().forEach(l -> serviceImportParseLogic - .addCapabilitiesProperties(newPropertiesMap, l)); + originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v)); + uploadComponentInstanceInfo.getCapabilities().values() + .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l)); updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap); } else { originCapabilities = originResource.getCapabilities(); @@ -1676,20 +2596,20 @@ public class ServiceImportBusinessLogic{ instCapabilties.put(currentCompInstance, originCapabilities); } - protected void updateCapabilityPropertiesValues(Either, JanusGraphOperationStatus> allDataTypes, Map> originCapabilities, Map> newPropertiesMap) { - originCapabilities.values().stream() - .flatMap(Collection::stream) - .filter(c -> newPropertiesMap.containsKey(c.getName())) - .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes.left().value())); + protected void updateCapabilityPropertiesValues(Map allDataTypes, + Map> originCapabilities, + Map> newPropertiesMap) { + originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName())) + .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes)); } protected void updatePropertyValues(List properties, Map newProperties, - Map allDataTypes) { + Map allDataTypes) { properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes)); } protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo, - Map allDataTypes) { + Map allDataTypes) { String value = null; List getInputs = null; boolean isValidate = true; @@ -1699,8 +2619,7 @@ public class ServiceImportBusinessLogic{ if (isValidate) { value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType()); } else { - value = getPropertyJsonStringValue(propertyInfo.getValue(), - TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); + value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName()); } } property.setValue(value); @@ -1712,10 +2631,10 @@ public class ServiceImportBusinessLogic{ log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource"); if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) { Either getOriginResourceRes = toscaOperationFacade - .getToscaFullElement(currentCompInstance.getComponentUid()); + .getToscaFullElement(currentCompInstance.getComponentUid()); if (getOriginResourceRes.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat( - componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName); throw new ComponentException(responseFormat); } originResource = getOriginResourceRes.left().value(); @@ -1726,42 +2645,21 @@ public class ServiceImportBusinessLogic{ return originResource; } - protected void handleSubstitutionMappings(Service service, Map uploadResInstancesMap) { - if (false) { - Either getResourceRes = toscaOperationFacade.getToscaFullElement(service.getUniqueId()); - if (getResourceRes.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), service, ComponentTypeEnum.SERVICE); - throw new ComponentException(responseFormat); - } - getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), - uploadResInstancesMap); - if (getResourceRes.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), service, ComponentTypeEnum.SERVICE); - throw new ComponentException(responseFormat); - } - } - } - protected Either updateCalculatedCapReqWithSubstitutionMappings(Resource resource, - Map uploadResInstancesMap) { + Map uploadResInstancesMap) { Either updateRes = null; Map>> updatedInstCapabilities = new HashMap<>(); Map>> updatedInstRequirements = new HashMap<>(); - StorageOperationStatus status = toscaOperationFacade - .deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId()); + 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); + 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.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, - resource); + fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities, + updatedInstRequirements); + status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource); if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { updateRes = Either.right(status); } @@ -1773,34 +2671,29 @@ public class ServiceImportBusinessLogic{ } protected void fillUpdatedInstCapabilitiesRequirements(List componentInstances, - Map uploadResInstancesMap, - Map>> updatedInstCapabilities, - Map>> updatedInstRequirements) { + 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()); + fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate()); + fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate()); }); } - protected void fillUpdatedInstCapabilities( - Map>> updatedInstCapabilties, - ComponentInstance instance, Map capabilitiesNamesToUpdate) { + protected 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(toList())); + 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(toList())); } } if (MapUtils.isNotEmpty(updatedCapabilities)) { @@ -1808,23 +2701,20 @@ public class ServiceImportBusinessLogic{ } } - protected void fillUpdatedInstRequirements( - Map>> updatedInstRequirements, - ComponentInstance instance, Map requirementsNamesToUpdate) { + protected 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(toList())); + 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(toList())); } } if (MapUtils.isNotEmpty(updatedRequirements)) { @@ -1832,7 +2722,8 @@ public class ServiceImportBusinessLogic{ } } - protected void addRelationsToRI(String yamlName, Service service, Map uploadResInstancesMap, List componentInstancesList, List relations) { + protected void addRelationsToRI(String yamlName, Service service, Map uploadResInstancesMap, + List componentInstancesList, List relations) { for (Map.Entry entry : uploadResInstancesMap.entrySet()) { UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue(); ComponentInstance currentCompInstance = null; @@ -1843,16 +2734,13 @@ public class ServiceImportBusinessLogic{ } } if (currentCompInstance == null) { - log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), - service.getUniqueId()); - BeEcompErrorManager.getInstance().logInternalDataError( - COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, - service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); - ResponseFormat responseFormat = componentsUtils - .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); + log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId()); + BeEcompErrorManager.getInstance() + .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(), + BeEcompErrorManager.ErrorSeverity.ERROR); + ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); throw new ComponentException(responseFormat); } - ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations); if (addRelationToRiRes.getStatus() != 200) { throw new ComponentException(addRelationToRiRes); @@ -1860,8 +2748,8 @@ public class ServiceImportBusinessLogic{ } } - protected ResponseFormat addRelationToRI(String yamlName, Service service, - UploadComponentInstanceInfo nodesInfoValue, List relations) { + protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue, + List relations) { List componentInstancesList = service.getComponentInstances(); ComponentInstance currentCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { @@ -1871,17 +2759,14 @@ public class ServiceImportBusinessLogic{ } } if (currentCompInstance == null) { - log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), - service.getUniqueId()); - BeEcompErrorManager.getInstance().logInternalDataError( - COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, - service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); - return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, - yamlName); + log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId()); + BeEcompErrorManager.getInstance() + .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(), + BeEcompErrorManager.ErrorSeverity.ERROR); + return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); } String resourceInstanceId = currentCompInstance.getUniqueId(); Map> regMap = nodesInfoValue.getRequirements(); - if (regMap != null) { Iterator>> nodesRegValue = regMap.entrySet().iterator(); while (nodesRegValue.hasNext()) { @@ -1893,18 +2778,14 @@ public class ServiceImportBusinessLogic{ RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef(); regCapRelDef.setFromNode(resourceInstanceId); log.debug("try to find available requirement {} ", regName); - Either eitherReqStatus = serviceImportParseLogic.findAviableRequiremen(regName, - yamlName, nodesInfoValue, currentCompInstance, - uploadRegInfo.getCapabilityName()); + Either eitherReqStatus = serviceImportParseLogic + .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName()); if (eitherReqStatus.isRight()) { - log.debug("failed to find available requirement {} status is {}", regName, - eitherReqStatus.right().value()); + 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(); + List reqAndRelationshipPairList = regCapRelDef.getRelationships(); if (reqAndRelationshipPairList == null) { reqAndRelationshipPairList = new ArrayList<>(); } @@ -1915,7 +2796,6 @@ public class ServiceImportBusinessLogic{ RelationshipImpl relationship = new RelationshipImpl(); relationship.setType(validReq.getCapability()); reqAndRelationshipPair.setRelationships(relationship); - ComponentInstance currentCapCompInstance = null; for (ComponentInstance compInstance : componentInstancesList) { if (compInstance.getName().equals(uploadRegInfo.getNode())) { @@ -1924,31 +2804,30 @@ public class ServiceImportBusinessLogic{ } } if (currentCapCompInstance == null) { - log.debug("The component instance with name {} not found on resource {} ", - uploadRegInfo.getNode(), service.getUniqueId()); - BeEcompErrorManager.getInstance().logInternalDataError( - COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, - service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); - return componentsUtils - .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); + log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId()); + BeEcompErrorManager.getInstance() + .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(), + BeEcompErrorManager.ErrorSeverity.ERROR); + return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); } regCapRelDef.setToNode(currentCapCompInstance.getUniqueId()); log.debug("try to find aviable Capability req name is {} ", validReq.getName()); - CapabilityDefinition aviableCapForRel = serviceImportParseLogic.findAvailableCapabilityByTypeOrName(validReq, - currentCapCompInstance, uploadRegInfo); - reqAndRelationshipPair.setCapability(aviableCapForRel.getName()); - reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId()); - reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId()); + CapabilityDefinition aviableCapForRel = serviceImportParseLogic + .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo); if (aviableCapForRel == null) { BeEcompErrorManager.getInstance().logInternalDataError( - "aviable capability was not found. req name is " + validReq.getName() - + " component instance is " + currentCapCompInstance.getUniqueId(), - service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); - return componentsUtils - .getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); + "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance + .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR); + return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); } + reqAndRelationshipPair.setCapability(aviableCapForRel.getName()); + reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId()); + reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId()); CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship(); capReqRel.setRelation(reqAndRelationshipPair); + if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) { + capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate())); + } reqAndRelationshipPairList.add(capReqRel); regCapRelDef.setRelationships(reqAndRelationshipPairList); relations.add(regCapRelDef); @@ -1958,19 +2837,27 @@ public class ServiceImportBusinessLogic{ return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName); } + private List getOperations(final Map> operations, final String relationshipTemplate) { + final List operationUiList = new ArrayList<>(); + operations.forEach((operationKey, operationValues) -> { + if (operationKey.equals(relationshipTemplate)) { + operationUiList.addAll(operationValues); + } + }); + return operationUiList; + } + protected Service getResourceAfterCreateRelations(Service service) { ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations(); - Either eitherGetResource = toscaOperationFacade - .getToscaElement(service.getUniqueId(), parametersView); + Either eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView); if (eitherGetResource.isRight()) { serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service); } return eitherGetResource.left().value(); } - protected Service createServiceInstances(String yamlName, Service service, - Map uploadResInstancesMap, - Map nodeNamespaceMap) { + protected Service createServiceInstances(String yamlName, Service service, Map uploadResInstancesMap, + Map nodeNamespaceMap) { Either eitherResource = null; log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName); if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances @@ -1982,52 +2869,48 @@ public class ServiceImportBusinessLogic{ nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v)); } Map resourcesInstancesMap = new HashMap<>(); - uploadResInstancesMap - .values() - .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap)); - + uploadResInstancesMap.values() + .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap)); if (MapUtils.isNotEmpty(resourcesInstancesMap)) { try { - toscaOperationFacade.associateComponentInstancesToComponent(service, - resourcesInstancesMap, false, false); + toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false); } catch (StorageException exp) { if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) { log.debug("Failed to add component instances to container component {}", service.getName()); ResponseFormat responseFormat = componentsUtils - .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus())); + .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus())); eitherResource = Either.right(responseFormat); throw new ComponentException(eitherResource.right().value()); } } } Either eitherGetResource = toscaOperationFacade - .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter()); + .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter()); log.debug("*************finished to get resource {}", service.getUniqueId()); if (eitherGetResource.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent( - componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service, ComponentTypeEnum.SERVICE); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service, + ComponentTypeEnum.SERVICE); throw new ComponentException(responseFormat); } if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances log.debug("Error when create resource instance from csar. ComponentInstances list empty"); - BeEcompErrorManager.getInstance().logBeDaoSystemError( - "Error when create resource instance from csar. ComponentInstances list empty"); + BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty"); throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE)); } return eitherGetResource.left().value(); } - protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, - Component component, Map nodeNamespaceMap, Map existingnodeTypeMap, Map resourcesInstancesMap) { + protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component, + Map nodeNamespaceMap, Map existingnodeTypeMap, + Map resourcesInstancesMap) { log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName()); try { if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) { - uploadComponentInstanceInfo - .setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName()); + uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName()); } - Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, - existingnodeTypeMap); - + Resource refResource = + validateResourceInstanceBeforeCreate(yamlName, component.getModel(), uploadComponentInstanceInfo, existingnodeTypeMap); ComponentInstance componentInstance = new ComponentInstance(); componentInstance.setComponentUid(refResource.getUniqueId()); Collection directives = uploadComponentInstanceInfo.getDirectives(); @@ -2036,98 +2919,105 @@ public class ServiceImportBusinessLogic{ } UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo(); if (uploadNodeFilterInfo != null) { - componentInstance.setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, - componentInstance.getUniqueId())); + componentInstance + .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId())); } - ComponentTypeEnum containerComponentType = component.getComponentType(); NodeTypeEnum containerNodeType = containerComponentType.getNodeType(); - if (containerNodeType.equals(NodeTypeEnum.Resource) - && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) - && MapUtils.isNotEmpty(refResource.getCapabilities())) { + if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils + .isNotEmpty(refResource.getCapabilities())) { serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities()); - Map> validComponentInstanceCapabilities = serviceImportParseLogic.getValidComponentInstanceCapabilities( - refResource.getUniqueId(), refResource.getCapabilities(), + Map> validComponentInstanceCapabilities = serviceImportParseLogic + .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities()); componentInstance.setCapabilities(validComponentInstanceCapabilities); } if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, - yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(), + uploadComponentInstanceInfo.getType()); throw new ComponentException(responseFormat); } Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType()); componentInstance.setName(uploadComponentInstanceInfo.getName()); componentInstance.setIcon(origResource.getIcon()); + componentInstance.setMinOccurrences(uploadComponentInstanceInfo.getMinOccurrences()); + componentInstance.setMaxOccurrences(uploadComponentInstanceInfo.getMaxOccurrences()); + componentInstance.setInstanceCount(uploadComponentInstanceInfo.getInstanceCount()); resourcesInstancesMap.put(componentInstance, origResource); - } catch (Exception e) { - throw new ComponentException(ActionStatus.GENERAL_ERROR,e.getMessage()); + } catch (final ComponentException e) { + throw e; + } catch (final Exception e) { + throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage()); } } - protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo, - Map nodeNamespaceMap) { + protected Resource validateResourceInstanceBeforeCreate(String yamlName, String model, UploadComponentInstanceInfo uploadComponentInstanceInfo, + Map nodeNamespaceMap) { Resource refResource; try { if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) { refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()); } else { - Either findResourceEither = toscaOperationFacade - .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType()); - if (findResourceEither.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat( - componentsUtils.convertFromStorageResponse(findResourceEither.right().value())); + final Either resourceEither = + toscaOperationFacade.getLatestByToscaResourceName(uploadComponentInstanceInfo.getType(), model); + if (resourceEither.isRight()) { + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceEither.right().value())); throw new ComponentException(responseFormat); } - refResource = findResourceEither.left().value(); + refResource = (Resource) resourceEither.left().value(); nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource); } String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState(); if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, - refResource.getComponentType().getValue(), refResource.getName(), componentState); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(), + componentState); throw new ComponentException(responseFormat); } if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) { log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType()); - ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, - yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType()); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(), + uploadComponentInstanceInfo.getType()); throw new ComponentException(responseFormat); } return refResource; - } catch (Exception e) { - throw new ComponentException(ActionStatus.GENERAL_ERROR,e.getMessage()); + } catch (final ComponentException e) { + throw e; + } catch (final Exception e) { + throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage()); } } - protected void handleServiceNodeTypes(String yamlName, Service service, - String topologyTemplateYaml, boolean needLock, - Map>> nodeTypesArtifactsToHandle, - List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, - CsarInfo csarInfo, String nodeName) { + protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, + CsarInfo csarInfo, String nodeName) { try { for (Map.Entry nodeTypeEntry : nodeTypesInfo.entrySet()) { boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey()); if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) { - handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, - nodeTypesInfo, csarInfo, nodeTypeEntry.getKey()); + handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, + nodeTypeEntry.getKey()); log.trace("************* finished to create node {}", nodeTypeEntry.getKey()); } } Map mappedToscaTemplate = null; - if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) - && nodeTypesInfo.containsKey(nodeName)) { + if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo + .containsKey(nodeName)) { mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate(); } if (MapUtils.isEmpty(mappedToscaTemplate)) { mappedToscaTemplate = (Map) new Yaml().load(topologyTemplateYaml); } createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle, - nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo); + nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo); } catch (ComponentException | StorageException e) { throw e; - } catch (Exception e){ - log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e); + } catch (Exception e) { + log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } @@ -2137,21 +3027,21 @@ public class ServiceImportBusinessLogic{ Either latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type); return latestResource.isRight(); } catch (Exception e) { - log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e); + log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e); throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected Resource handleNestedVF(Service service, Map>> nodesArtifactsToHandle, - List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, - String nodeName) { + protected Resource handleNestedVF(Service service, + Map>> nodesArtifactsToHandle, + List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, + String nodeName) { try { String yamlName = nodesInfo.get(nodeName).getTemplateFileName(); Map nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate(); - - createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo); + createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo, + csarInfo); log.debug("************* Finished to create node types from yaml {}", yamlName); - if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) { log.debug("************* Going to handle complex VFC from yaml {}", yamlName); return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName); @@ -2163,41 +3053,40 @@ public class ServiceImportBusinessLogic{ } } - protected Resource handleComplexVfc(Map>> nodesArtifactsToHandle, - List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, - String nodeName, String yamlName) { + protected Resource handleComplexVfc( + Map>> nodesArtifactsToHandle, + List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) { try { Resource oldComplexVfc = null; Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo); Either oldComplexVfcRes = toscaOperationFacade - .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName()); + .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName()); if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) { oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName( - serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), - nodeName).getRight()); + serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.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()); + log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(), + oldComplexVfcRes.right().value()); throw new ComponentException(ActionStatus.GENERAL_ERROR); } else if (oldComplexVfcRes.isLeft()) { log.debug(VALIDATE_DERIVED_BEFORE_UPDATE); - Either eitherValidation = serviceImportParseLogic.validateNestedDerivedFromDuringUpdate( - oldComplexVfcRes.left().value(), newComplexVfc, + Either eitherValidation = serviceImportParseLogic + .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc, ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion())); if (eitherValidation.isLeft()) { oldComplexVfc = oldComplexVfcRes.left().value(); } } - newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, - oldComplexVfc, newComplexVfc); + newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc, + newComplexVfc); csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName()); - LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction( - CERTIFICATION_ON_IMPORT, LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR); + LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT, + LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR); log.debug("Going to certify cvfc {}. ", newComplexVfc.getName()); final Resource result = serviceImportParseLogic - .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, - true); + .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true); csarInfo.getCreatedNodes().put(nodeName, result); csarInfo.removeNodeFromQueue(); return result; @@ -2207,23 +3096,23 @@ public class ServiceImportBusinessLogic{ } } - protected Resource handleComplexVfc(Map>> nodesArtifactsToHandle, - List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, - String nodeName, String yamlName, Resource oldComplexVfc, Resource newComplexVfc) { + protected Resource handleComplexVfc( + Map>> nodesArtifactsToHandle, + List createdArtifacts, Map nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName, + Resource oldComplexVfc, Resource newComplexVfc) { Resource handleComplexVfcRes; try { Map mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate(); String yamlContent = new String(csarInfo.getCsar().get(yamlName)); Map newNodeTypesInfo = nodesInfo.entrySet().stream() - .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy())); + .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy())); CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo); if (oldComplexVfc == null) { - handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, - csarInfo, nodesArtifactsToHandle, false, true, nodeName); + handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle, + false, true, nodeName); } else { - handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, - AuditingActionEnum.UPDATE_RESOURCE_METADATA, createdArtifacts, yamlContent, yamlName, csarInfo, - newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true); + handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA, + createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true); } return handleComplexVfcRes; } catch (Exception e) { @@ -2232,45 +3121,48 @@ public class ServiceImportBusinessLogic{ } } - protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, - AuditingActionEnum actionEnum, List createdArtifacts, - String yamlFileName, String yamlFileContent, CsarInfo csarInfo, Map nodeTypesInfo, - Map>> nodeTypesArtifactsToHandle, - String nodeName, boolean isNested) { + protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum, + List createdArtifacts, String yamlFileName, String yamlFileContent, + CsarInfo csarInfo, Map nodeTypesInfo, + Map>> nodeTypesArtifactsToHandle, + String nodeName, boolean isNested) { boolean inTransaction = true; boolean shouldLock = false; Resource preparedResource = null; ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null; try { - uploadComponentInstanceInfoMap = csarBusinessLogic.getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource); + uploadComponentInstanceInfoMap = csarBusinessLogic + .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource); Map instances = uploadComponentInstanceInfoMap.getInstances(); if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) { throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName); } - preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), - inTransaction, shouldLock, isNested).left; + preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock, + isNested).left; log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent); serviceImportParseLogic.handleResourceGenericType(preparedResource); - handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, - shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo, csarInfo, nodeName); - preparedResource = serviceImportParseLogic - .createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs()); + handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo, + csarInfo, nodeName); + preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs()); preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes()); preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances); } catch (ComponentException e) { - ResponseFormat responseFormat = e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat(); + ResponseFormat responseFormat = + e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat(); log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat); - componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum); + componentsUtils + .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum); throw e; } catch (StorageException e) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat); - componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum); + componentsUtils + .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum); throw e; } - Either, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic - .validateUpdateVfGroupNames(uploadComponentInstanceInfoMap.getGroups(), - preparedResource.getSystemName()); + Either, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames( + uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName()); if (validateUpdateVfGroupNamesRes.isRight()) { throw new ComponentException(validateUpdateVfGroupNamesRes.right().value()); } @@ -2282,66 +3174,62 @@ public class ServiceImportBusinessLogic{ } serviceImportParseLogic.handleGroupsProperties(preparedResource, groups); preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups); - NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, - nodeTypesArtifactsToHandle); - - Either updateArtifactsEither = createOrUpdateArtifacts( - ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, createdArtifacts, yamlFileName, - csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); + NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle); + Either updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, + createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); if (updateArtifactsEither.isRight()) { log.debug("failed to update artifacts {}", updateArtifactsEither.right().value()); throw new ComponentException(updateArtifactsEither.right().value()); } preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId()); - ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource); if (mergingPropsAndInputsStatus != ActionStatus.OK) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, - preparedResource); + ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource); throw new ComponentException(responseFormat); } compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId()); return preparedResource; } - protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, - String yamlName, Map nodeTypesInfo, CsarInfo csarInfo, - Map>> nodeTypesArtifactsToCreate, - boolean shouldLock, boolean inTransaction, String nodeName) { + protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName, + Map nodeTypesInfo, CsarInfo csarInfo, + Map>> nodeTypesArtifactsToCreate, + boolean shouldLock, boolean inTransaction, String nodeName) { List createdArtifacts = new ArrayList<>(); Resource createdResource; try { - ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource); + ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic + .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource); if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) { throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName); } log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName()); - createdResource = createResourceAndRIsFromYaml(yamlName, resource, - parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false, createdArtifacts, topologyTemplateYaml, - nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName); + createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false, + createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName); log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName()); } catch (ComponentException e) { - ResponseFormat responseFormat = e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat(); + ResponseFormat responseFormat = + e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat(); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); throw e; } catch (StorageException e) { - ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); + ResponseFormat responseFormat = componentsUtils + .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus())); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); throw e; } return createdResource; } - protected Resource 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) { + protected Resource 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) { List nodeTypesNewCreatedArtifacts = new ArrayList<>(); if (shouldLock) { - Either lockResult = serviceBusinessLogic.lockComponentByName(resource.getSystemName(), resource, - CREATE_RESOURCE); + Either lockResult = serviceBusinessLogic + .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE); if (lockResult.isRight()) { serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(lockResult.right().value()); @@ -2351,58 +3239,48 @@ public class ServiceImportBusinessLogic{ try { log.trace("************* createResourceFromYaml before full create resource {}", yamlName); Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource); - resource = createResourceTransaction(resource, - csarInfo.getModifier(), isNormative); + resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative); log.trace("************* Going to add inputs from yaml {}", yamlName); - Map yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent()); Map metadata = (Map) yamlMap.get("metadata"); String type = (String) metadata.get("type"); - if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) + if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) { serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource); + } Map inputs = parsedToscaYamlInfo.getInputs(); resource = serviceImportParseLogic.createInputsOnResource(resource, inputs); - Map uploadComponentInstanceInfoMap = parsedToscaYamlInfo - .getInstances(); - resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, - topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, - nodeTypesArtifactsToCreate, nodeName); + Map uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances(); + resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml, + nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName); log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName); // validate update vf module group names - Either, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic - .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), resource.getSystemName()); + Either, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames( + parsedToscaYamlInfo.getGroups(), resource.getSystemName()); if (validateUpdateVfGroupNamesRes.isRight()) { serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(validateUpdateVfGroupNamesRes.right().value()); } 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, - groups); + Either createGroupsOnResource = createGroupsOnResource(resource, groups); if (createGroupsOnResource.isRight()) { serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(createGroupsOnResource.right().value()); } resource = createGroupsOnResource.left().value(); log.trace("************* Going to add artifacts from yaml {}", yamlName); - NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate); - - Either createArtifactsEither = createOrUpdateArtifacts( - ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, createdArtifacts, yamlName, - csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); + Either createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, + createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock); if (createArtifactsEither.isRight()) { serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts); throw new ComponentException(createArtifactsEither.right().value()); } - resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId()); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED); componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum); @@ -2413,34 +3291,30 @@ public class ServiceImportBusinessLogic{ throw e; } finally { if (!inTransaction) { - serviceBusinessLogic.janusGraphDao.commit(); + janusGraphDao.commit(); } if (shouldLock) { - serviceBusinessLogic.graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource); + graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource); } } } - protected Either createGroupsOnResource(Resource resource, - Map groups) { + protected Either createGroupsOnResource(Resource resource, Map groups) { if (groups != null && !groups.isEmpty()) { - List groupsAsList = updateGroupsMembersUsingResource( - groups, resource); + List groupsAsList = updateGroupsMembersUsingResource(groups, resource); serviceImportParseLogic.handleGroupsProperties(resource, groups); serviceImportParseLogic.fillGroupsFinalFields(groupsAsList); - Either, ResponseFormat> createGroups = serviceBusinessLogic.groupBusinessLogic.createGroups(resource, - groupsAsList, true); + Either, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true); if (createGroups.isRight()) { return Either.right(createGroups.right().value()); } } else { return Either.left(resource); } - Either updatedResource = toscaOperationFacade - .getToscaElement(resource.getUniqueId()); + Either updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId()); if (updatedResource.isRight()) { - ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource( - componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource); + ResponseFormat responseFormat = componentsUtils + .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource); return Either.right(responseFormat); } return Either.left(updatedResource.left().value()); @@ -2449,12 +3323,7 @@ public class ServiceImportBusinessLogic{ protected List updateGroupsMembersUsingResource(Map groups, Resource component) { List result = new ArrayList<>(); List componentInstances = component.getComponentInstances(); - if (groups != null) { - Either validateCyclicGroupsDependencies = serviceImportParseLogic.validateCyclicGroupsDependencies(groups); - if (validateCyclicGroupsDependencies.isRight()) { - throw new ComponentException(validateCyclicGroupsDependencies.right().value()); - } for (Map.Entry entry : groups.entrySet()) { String groupName = entry.getKey(); GroupDefinition groupDefinition = entry.getValue(); @@ -2470,23 +3339,21 @@ public class ServiceImportBusinessLogic{ return result; } - protected void updateGroupMembers(Map groups, GroupDefinition updatedGroupDefinition, Resource component, List componentInstances, String groupName, Map members) { + protected void updateGroupMembers(Map groups, GroupDefinition updatedGroupDefinition, Resource component, + List componentInstances, String groupName, Map members) { Set compInstancesNames = members.keySet(); if (CollectionUtils.isEmpty(componentInstances)) { String membersAstString = compInstancesNames.stream().collect(joining(",")); - log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", - membersAstString, groupName, component.getNormalizedName()); - throw new ComponentException(componentsUtils.getResponseFormat( - ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, - component.getNormalizedName(), serviceImportParseLogic.getComponentTypeForResponse(component))); - } - Map memberNames = componentInstances.stream() - .collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId)); + log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString, + groupName, component.getNormalizedName()); + throw new ComponentException(componentsUtils + .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(), + serviceImportParseLogic.getComponentTypeForResponse(component))); + } + Map memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId)); memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> ""))); - Map relevantInstances = memberNames.entrySet().stream() - .filter(n -> compInstancesNames.contains(n.getKey())) - .collect(toMap(Map.Entry::getKey, Map.Entry::getValue)); - + Map relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey())) + .collect(toMap(Map.Entry::getKey, Map.Entry::getValue)); if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) { List foundMembers = new ArrayList<>(); if (relevantInstances != null) { @@ -2494,26 +3361,25 @@ public class ServiceImportBusinessLogic{ } compInstancesNames.removeAll(foundMembers); String membersAstString = compInstancesNames.stream().collect(joining(",")); - throw new ComponentException(componentsUtils.getResponseFormat( - ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, - component.getNormalizedName(), serviceImportParseLogic.getComponentTypeForResponse(component))); + throw new ComponentException(componentsUtils + .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(), + serviceImportParseLogic.getComponentTypeForResponse(component))); } updatedGroupDefinition.setMembers(relevantInstances); } - protected Resource createResourceTransaction(Resource resource, User user, - boolean isNormative) { - Either eitherValidation = toscaOperationFacade.validateComponentNameExists( - resource.getName(), resource.getResourceType(), resource.getComponentType()); + protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) { + Either eitherValidation = toscaOperationFacade + .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType()); if (eitherValidation.isRight()) { ResponseFormat errorResponse = componentsUtils - .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value())); + .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value())); throw new ComponentException(errorResponse); } - if (eitherValidation.left().value()) { + if (Boolean.TRUE.equals(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()); + ResponseFormat errorResponse = componentsUtils + .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName()); throw new ComponentException(errorResponse); } log.debug("send resource {} to dao for create", resource.getName()); @@ -2527,48 +3393,42 @@ public class ServiceImportBusinessLogic{ resource.setAbstract(false); } } - return toscaOperationFacade.createToscaComponent(resource) - .left() - .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource)); + return toscaOperationFacade.createToscaComponent(resource).left() + .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource)); } - protected ImmutablePair updateExistingResourceByImport( - Resource newResource, Resource oldResource, User user, boolean inTransaction, boolean needLock, - boolean isNested) { + protected ImmutablePair 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()); + log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(), + oldResource.getLifecycleState()); ImmutablePair resourcePair = null; try { serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import"); - oldResource = serviceImportParseLogic - .prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false); + oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false); serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource); serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested); - serviceImportParseLogic - .validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource, AuditingActionEnum.IMPORT_RESOURCE, inTransaction); + serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource, + AuditingActionEnum.IMPORT_RESOURCE, inTransaction); createNewResourceToOldResource(newResource, oldResource, user); - - Either overrideResource = toscaOperationFacade - .overrideComponent(newResource, oldResource); + Either overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource); if (overrideResource.isRight()) { ResponseFormat responseFormat = new ResponseFormat(); serviceBusinessLogic.throwComponentException(responseFormat); } log.debug("Resource updated successfully!!!"); - resourcePair = new ImmutablePair<>(overrideResource.left().value(), - ActionStatus.OK); + resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK); return resourcePair; } finally { if (resourcePair == null) { BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify"); - serviceBusinessLogic.janusGraphDao.rollback(); + janusGraphDao.rollback(); } else if (!inTransaction) { - serviceBusinessLogic.janusGraphDao.commit(); + janusGraphDao.commit(); } if (needLock) { log.debug("unlock resource {}", lockedResourceId); - serviceBusinessLogic.graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource); + graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource); } } } @@ -2589,6 +3449,9 @@ public class ServiceImportBusinessLogic{ if (oldResource.getCsarUUID() != null) { newResource.setCsarUUID(oldResource.getCsarUUID()); } + if (oldResource.getCsarVersionId() != null) { + newResource.setCsarVersionId(oldResource.getCsarVersionId()); + } if (oldResource.getImportedToscaChecksum() != null) { newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum()); } @@ -2607,60 +3470,62 @@ public class ServiceImportBusinessLogic{ if (CollectionUtils.isEmpty(newResource.getProperties())) { newResource.setProperties(oldResource.getProperties()); } + if (newResource.getModel() == null) { + newResource.setModel(oldResource.getModel()); + } } - protected Map createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map mappedToscaTemplate, boolean needLock, - Map>> nodeTypesArtifactsToHandle, - List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, - CsarInfo csarInfo) { + protected Map createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map mappedToscaTemplate, + boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, + Map nodeTypesInfo, CsarInfo csarInfo) { try { Either toscaVersion = findFirstToscaStringElement(mappedToscaTemplate, - TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION); + TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION); if (toscaVersion.isRight()) { throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE); } Map mapToConvert = new HashMap<>(); mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value()); Map nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate); - createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert, nodeTypes); + createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, + mapToConvert, nodeTypes); return csarInfo.getCreatedNodes(); } catch (Exception e) { - log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}",e.getMessage(),e); - throw new ComponentException(ActionStatus.GENERAL_ERROR); + log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e); + throw new ComponentException(ActionStatus.GENERAL_ERROR); } } - protected void createNodeTypes(String yamlName, Service service, boolean needLock, Map>> nodeTypesArtifactsToHandle, List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, Map mapToConvert, Map nodeTypes) { + protected void createNodeTypes(String yamlName, Service service, boolean needLock, + Map>> nodeTypesArtifactsToHandle, + List nodeTypesNewCreatedArtifacts, Map nodeTypesInfo, CsarInfo csarInfo, + Map mapToConvert, Map nodeTypes) { Iterator> nodesNameValueIter = nodeTypes.entrySet().iterator(); Resource vfcCreated = null; while (nodesNameValueIter.hasNext()) { Map.Entry nodeType = nodesNameValueIter.next(); - Map> nodeTypeArtifactsToHandle = nodeTypesArtifactsToHandle == null - || nodeTypesArtifactsToHandle.isEmpty() ? null - : nodeTypesArtifactsToHandle.get(nodeType.getKey()); - - if (nodeTypesInfo.containsKey(nodeType.getKey())) { - vfcCreated = handleNestedVfc(service, - nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, - nodeType.getKey()); - log.trace("************* Finished to handle nested vfc {}", nodeType.getKey()); - } else if (csarInfo.getCreatedNodesToscaResourceNames() != null - && !csarInfo.getCreatedNodesToscaResourceNames().containsKey(nodeType.getKey())) { + String nodeTypeKey = nodeType.getKey(); + Map> nodeTypeArtifactsToHandle = + nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey); + if (nodeTypesInfo.containsKey(nodeTypeKey)) { + vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, + nodeTypeKey); + log.trace("************* Finished to handle nested vfc {}", nodeTypeKey); + } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames() + .containsKey(nodeTypeKey)) { ImmutablePair resourceCreated = serviceImportParseLogic - .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, - service, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, - csarInfo, true); - log.debug("************* Finished to create node {}", nodeType.getKey()); - + .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock, + nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true); + log.debug("************* Finished to create node {}", nodeTypeKey); vfcCreated = resourceCreated.getLeft(); - csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), - vfcCreated.getName()); + csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName()); } if (vfcCreated != null) { - csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated); + csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated); } mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName()); } } - }