From 2623c8402a57e2035db69a9d92d2851050916801 Mon Sep 17 00:00:00 2001 From: shrikantawachar Date: Mon, 20 May 2019 12:11:54 +0530 Subject: Upgrade SDC from Titan to Janus Graph Upgrade SDC from Titan to Janus Graph Change-Id: I67fb8b8e60cc6751697bc5ff2f06754c92803786 Issue-ID: SDC-2296 Signed-off-by: shrikantawachar --- .../sdc/be/config/CatalogModelSpringConfig.java | 4 +- .../java/org/openecomp/sdc/be/model/Component.java | 2 +- .../sdc/be/model/DerivedNodeTypeResolver.java | 4 +- .../java/org/openecomp/sdc/be/model/Service.java | 6 +- .../sdc/be/model/cache/ApplicationCache.java | 6 +- .../be/model/cache/ApplicationDataTypeCache.java | 20 +- .../sdc/be/model/cache/ComponentCache.java | 6 +- .../org/openecomp/sdc/be/model/cache/DaoInfo.java | 2 +- .../sdc/be/model/cache/workers/SyncWorker.java | 26 +- .../model/jsonjanusgraph/datamodel/NodeType.java | 71 + .../jsonjanusgraph/datamodel/TopologyTemplate.java | 310 +++ .../jsonjanusgraph/datamodel/ToscaElement.java | 344 +++ .../datamodel/ToscaElementTypeEnum.java | 49 + .../jsonjanusgraph/enums/JsonConstantKeysEnum.java | 42 + .../operations/ArchiveOperation.java | 292 ++ .../operations/ArtifactsOperations.java | 760 ++++++ .../jsonjanusgraph/operations/BaseOperation.java | 1518 +++++++++++ .../ByToscaNameDerivedNodeTypeResolver.java | 56 + .../operations/CapabilitiesOperation.java | 156 ++ .../operations/CategoryOperation.java | 94 + .../operations/ExternalReferencesOperation.java | 297 +++ .../operations/ForwardingPathOperation.java | 118 + .../jsonjanusgraph/operations/GroupsOperation.java | 397 +++ .../operations/InstancesOperation.java | 25 + .../operations/InterfaceOperation.java | 98 + .../operations/NodeFilterOperation.java | 176 ++ .../operations/NodeTemplateOperation.java | 2417 +++++++++++++++++ .../operations/NodeTypeOperation.java | 979 +++++++ .../jsonjanusgraph/operations/PolicyOperation.java | 62 + .../operations/RequirementOperation.java | 92 + .../operations/TopologyTemplateOperation.java | 1623 ++++++++++++ .../operations/ToscaDataOperation.java | 25 + .../operations/ToscaElementLifecycleOperation.java | 1636 ++++++++++++ .../operations/ToscaElementOperation.java | 1405 ++++++++++ .../operations/ToscaOperationFacade.java | 2792 ++++++++++++++++++++ .../operations/UpgradeOperation.java | 231 ++ .../utils/CapabilityRequirementNameResolver.java | 394 +++ .../be/model/jsonjanusgraph/utils/IdMapper.java | 53 + .../model/jsonjanusgraph/utils/ModelConverter.java | 1730 ++++++++++++ .../sdc/be/model/jsontitan/datamodel/NodeType.java | 71 - .../jsontitan/datamodel/TopologyTemplate.java | 311 --- .../be/model/jsontitan/datamodel/ToscaElement.java | 344 --- .../jsontitan/datamodel/ToscaElementTypeEnum.java | 49 - .../jsontitan/enums/JsonConstantKeysEnum.java | 42 - .../jsontitan/operations/ArchiveOperation.java | 284 -- .../jsontitan/operations/ArtifactsOperations.java | 758 ------ .../model/jsontitan/operations/BaseOperation.java | 1495 ----------- .../ByToscaNameDerivedNodeTypeResolver.java | 55 - .../operations/CapabilitiesOperation.java | 155 -- .../jsontitan/operations/CategoryOperation.java | 91 - .../operations/ExternalReferencesOperation.java | 297 --- .../operations/ForwardingPathOperation.java | 117 - .../jsontitan/operations/GroupsOperation.java | 395 --- .../jsontitan/operations/InstancesOperation.java | 25 - .../jsontitan/operations/InterfaceOperation.java | 98 - .../jsontitan/operations/NodeFilterOperation.java | 175 -- .../operations/NodeTemplateOperation.java | 2400 ----------------- .../jsontitan/operations/NodeTypeOperation.java | 962 ------- .../jsontitan/operations/PolicyOperation.java | 62 - .../jsontitan/operations/RequirementOperation.java | 92 - .../operations/TopologyTemplateOperation.java | 1624 ------------ .../jsontitan/operations/ToscaDataOperation.java | 25 - .../operations/ToscaElementLifecycleOperation.java | 1583 ----------- .../operations/ToscaElementOperation.java | 1360 ---------- .../jsontitan/operations/ToscaOperationFacade.java | 2743 ------------------- .../jsontitan/operations/UpgradeOperation.java | 225 -- .../utils/CapabilityRequirementNameResolver.java | 394 --- .../sdc/be/model/jsontitan/utils/IdMapper.java | 53 - .../be/model/jsontitan/utils/ModelConverter.java | 1731 ------------ .../sdc/be/model/operations/StorageException.java | 12 +- .../api/IAdditionalInformationOperation.java | 28 +- .../model/operations/api/IArtifactOperation.java | 4 +- .../model/operations/api/ICapabilityOperation.java | 4 +- .../operations/api/ICapabilityTypeOperation.java | 4 +- .../be/model/operations/api/IInputsOperation.java | 4 +- .../model/operations/impl/AbstractOperation.java | 70 +- .../impl/AdditionalInformationOperation.java | 271 +- .../model/operations/impl/ArtifactOperation.java | 153 +- .../operations/impl/CacheMangerOperation.java | 10 +- .../model/operations/impl/CapabilityOperation.java | 106 +- .../operations/impl/CapabilityTypeOperation.java | 116 +- .../operations/impl/CommonTypeOperations.java | 35 +- .../impl/ComponentInstanceOperation.java | 209 +- .../model/operations/impl/ConsumerOperation.java | 48 +- .../model/operations/impl/DaoStatusConverter.java | 10 +- .../impl/DefaultDerivedFromOperation.java | 53 +- .../be/model/operations/impl/ElementOperation.java | 262 +- .../model/operations/impl/GraphLockOperation.java | 32 +- .../operations/impl/GroupInstanceOperation.java | 224 +- .../be/model/operations/impl/GroupOperation.java | 101 +- .../model/operations/impl/GroupTypeOperation.java | 150 +- .../operations/impl/HeatParametersOperation.java | 130 +- .../be/model/operations/impl/InputsOperation.java | 72 +- .../impl/InterfaceLifecycleOperation.java | 271 +- .../be/model/operations/impl/OperationUtils.java | 33 +- .../model/operations/impl/PolicyTypeOperation.java | 46 +- .../model/operations/impl/PropertyOperation.java | 541 ++-- .../operations/impl/RelationshipTypeOperation.java | 135 +- .../model/operations/impl/UserAdminOperation.java | 82 +- .../operations/utils/ComponentValidationUtils.java | 2 +- 100 files changed, 20020 insertions(+), 19532 deletions(-) create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeType.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplate.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElement.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnum.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnum.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperations.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/BaseOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ByToscaNameDerivedNodeTypeResolver.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CategoryOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ForwardingPathOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InstancesOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTypeOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/RequirementOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaDataOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementLifecycleOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperation.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityRequirementNameResolver.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapper.java create mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverter.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeType.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplate.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElement.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnum.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnum.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/BaseOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ByToscaNameDerivedNodeTypeResolver.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CategoryOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ForwardingPathOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InstancesOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeFilterOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/RequirementOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaDataOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementLifecycleOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperation.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityRequirementNameResolver.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapper.java delete mode 100644 catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java (limited to 'catalog-model/src/main') diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/config/CatalogModelSpringConfig.java b/catalog-model/src/main/java/org/openecomp/sdc/be/config/CatalogModelSpringConfig.java index 6ba7a35836..5b9cf67dc1 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/config/CatalogModelSpringConfig.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/config/CatalogModelSpringConfig.java @@ -8,8 +8,8 @@ import org.springframework.context.annotation.Configuration; @Configuration @ComponentScan({"org.openecomp.sdc.be.model.operations.impl", "org.openecomp.sdc.be.model.cache", - "org.openecomp.sdc.be.model.jsontitan.utils", - "org.openecomp.sdc.be.model.jsontitan.operations", + "org.openecomp.sdc.be.model.jsonjanusgraph.utils", + "org.openecomp.sdc.be.model.jsonjanusgraph.operations", "org.openecomp.sdc.be.dao.cassandra" }) public class CatalogModelSpringConfig { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.java index b65997cb35..0a77ecd471 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.java @@ -48,7 +48,7 @@ import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.model.category.CategoryDefinition; import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import static java.util.stream.Collectors.toMap; diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DerivedNodeTypeResolver.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DerivedNodeTypeResolver.java index 5104a172b5..5a670890a9 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DerivedNodeTypeResolver.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DerivedNodeTypeResolver.java @@ -21,13 +21,13 @@ package org.openecomp.sdc.be.model; import fj.data.Either; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import java.util.List; public interface DerivedNodeTypeResolver { - Either, TitanOperationStatus> findDerivedResources(String parentResource); + Either, JanusGraphOperationStatus> findDerivedResources(String parentResource); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/Service.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/Service.java index 3c1ca26879..4920d4f10c 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/Service.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/Service.java @@ -23,17 +23,13 @@ package org.openecomp.sdc.be.model; import org.apache.commons.lang.StringUtils; import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition; import java.util.HashMap; -import java.util.List; import java.util.Map; import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.InstantiationTypes; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; - -import java.util.HashMap; -import java.util.Map; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; public class Service extends Component { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java index e9b7f7a2e5..e70ab0ec63 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java @@ -21,14 +21,14 @@ package org.openecomp.sdc.be.model.cache; import fj.data.Either; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import java.util.Map; public interface ApplicationCache { - public abstract Either, TitanOperationStatus> getAll(); + public abstract Either, JanusGraphOperationStatus> getAll(); - public abstract Either get(String uniqueId); + public abstract Either get(String uniqueId); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java index 94992111d3..fb49762736 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java @@ -28,7 +28,7 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.config.Configuration.ApplicationL1CacheConfig; import org.openecomp.sdc.be.config.Configuration.ApplicationL1CacheInfo; import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; @@ -146,7 +146,7 @@ public class ApplicationDataTypeCache implements ApplicationCache, TitanOperationStatus> getAllDataTypesFromGraph() { + private Either, JanusGraphOperationStatus> getAllDataTypesFromGraph() { return propertyOperation .getAllDataTypes(); @@ -154,7 +154,7 @@ public class ApplicationDataTypeCache implements ApplicationCache, TitanOperationStatus> getAll() { + public Either, JanusGraphOperationStatus> getAll() { try { @@ -171,7 +171,7 @@ public class ApplicationDataTypeCache implements ApplicationCache get(String uniqueId) { + public Either get(String uniqueId) { try { r.lock(); @@ -202,12 +202,12 @@ public class ApplicationDataTypeCache implements ApplicationCache, TitanOperationStatus> allDataTypeNodes = propertyOperation.getAllDataTypeNodes(); + Either, JanusGraphOperationStatus> allDataTypeNodes = propertyOperation.getAllDataTypeNodes(); Long end = System.currentTimeMillis(); log.trace("Finish fetching all data types from db. Took {} Milliseconds", (end - start)); if (allDataTypeNodes.isRight()) { - TitanOperationStatus status = allDataTypeNodes.right().value(); - if (status != TitanOperationStatus.OK) { + JanusGraphOperationStatus status = allDataTypeNodes.right().value(); + if (status != JanusGraphOperationStatus.OK) { log.debug("ApplicationDataTypesCache - Failed to fetch all data types nodes"); BeEcompErrorManager.getInstance().logInternalConnectionError("FetchDataTypes", "Failed to fetch data types from graph(cache)", ErrorSeverity.INFO); @@ -251,7 +251,7 @@ public class ApplicationDataTypeCache implements ApplicationCache, TitanOperationStatus> allDataTypes = propertyOperation + Either, JanusGraphOperationStatus> allDataTypes = propertyOperation .getAllDataTypes(); if (allDataTypes.isRight()) { - TitanOperationStatus status = allDataTypes.right().value(); + JanusGraphOperationStatus status = allDataTypes.right().value(); log.debug("Failed to fetch all data types from db. Status is {}", status); } else { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ComponentCache.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ComponentCache.java index b17a66434a..0fea33e8e5 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ComponentCache.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ComponentCache.java @@ -37,7 +37,7 @@ 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.model.*; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.resources.data.ComponentCacheData; import org.openecomp.sdc.common.log.wrappers.Logger; import org.openecomp.sdc.common.util.SerializationUtils; @@ -54,10 +54,6 @@ import java.util.stream.Collectors; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantReadWriteLock; -import java.util.function.Function; -import java.util.stream.Collectors; @org.springframework.stereotype.Component("component-cache") public class ComponentCache { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/DaoInfo.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/DaoInfo.java index 4880afee81..85a7f2ec59 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/DaoInfo.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/DaoInfo.java @@ -20,7 +20,7 @@ package org.openecomp.sdc.be.model.cache; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; public class DaoInfo { private ToscaOperationFacade toscaOperationFacade; diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/workers/SyncWorker.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/workers/SyncWorker.java index 7af806f55c..cd78063780 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/workers/SyncWorker.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/workers/SyncWorker.java @@ -22,7 +22,7 @@ package org.openecomp.sdc.be.model.cache.workers; import fj.data.Either; import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.operations.impl.CacheMangerOperation; @@ -85,7 +85,7 @@ public class SyncWorker implements Runnable, IWorker { log.debug("sync worker:{} encounered an exception", workerName); log.debug("exception", e); } finally { - this.cacheMangerOperation.getTitanGenericDao().commit(); + this.cacheMangerOperation.getJanusGraphGenericDao().commit(); } } @@ -97,11 +97,11 @@ public class SyncWorker implements Runnable, IWorker { private void clearCacheRecords() { cacheIdAndTimeMap.forEach((k, v) -> { try { - Either componentFromGraphRes = getComponentMetaData(k, + Either componentFromGraphRes = getComponentMetaData(k, NodeTypeEnum.getByName(v.getType())); if (componentFromGraphRes.isRight()) { - TitanOperationStatus error = componentFromGraphRes.right().value(); - if (TitanOperationStatus.NOT_FOUND.equals(error)) { + JanusGraphOperationStatus error = componentFromGraphRes.right().value(); + if (JanusGraphOperationStatus.NOT_FOUND.equals(error)) { long delay = System.currentTimeMillis() - v.getModificationTime().getTime(); if (delay > updateDelayInMilliseconds) { this.cacheMangerOperation.deleteComponentInCache(k, v.getModificationTime().getTime(), @@ -148,11 +148,11 @@ public class SyncWorker implements Runnable, IWorker { private void syncCacheByComponentType(NodeTypeEnum nodeTypeEnum) { if (!this.shutdown) { log.trace("syncCache records of type:{} .", nodeTypeEnum); - Either, TitanOperationStatus> getAllResult = getAllComponentsMetaData( + Either, JanusGraphOperationStatus> getAllResult = getAllComponentsMetaData( nodeTypeEnum); List componentList = new ArrayList<>(); - if (getAllResult.isRight() && !TitanOperationStatus.NOT_FOUND.equals(getAllResult.right().value())) { - log.debug("error while trying to get all components of type:{} TitanOperationStatus:{}.", nodeTypeEnum, + if (getAllResult.isRight() && !JanusGraphOperationStatus.NOT_FOUND.equals(getAllResult.right().value())) { + log.debug("error while trying to get all components of type:{} JanusGraphOperationStatus:{}.", nodeTypeEnum, getAllResult.right().value()); return; } @@ -243,9 +243,9 @@ public class SyncWorker implements Runnable, IWorker { * @return a list of retrieved nodes matching the given type or not found in * case no nodes were found or error in case of failure */ - private Either, TitanOperationStatus> getAllComponentsMetaData( + private Either, JanusGraphOperationStatus> getAllComponentsMetaData( NodeTypeEnum nodeTypeEnum) { - return this.cacheMangerOperation.getTitanGenericDao().getByCriteria(nodeTypeEnum, null, + return this.cacheMangerOperation.getJanusGraphGenericDao().getByCriteria(nodeTypeEnum, null, ComponentMetadataData.class); } @@ -259,9 +259,9 @@ public class SyncWorker implements Runnable, IWorker { * @return the meta dat of the component or the error encountered during the * get */ - private Either getComponentMetaData(String uid, - NodeTypeEnum nodeTypeEnum) { - return this.cacheMangerOperation.getTitanGenericDao().getNode(UniqueIdBuilder.getKeyByNodeType(nodeTypeEnum), + private Either getComponentMetaData(String uid, + NodeTypeEnum nodeTypeEnum) { + return this.cacheMangerOperation.getJanusGraphGenericDao().getNode(UniqueIdBuilder.getKeyByNodeType(nodeTypeEnum), uid, ComponentMetadataData.class); } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeType.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeType.java new file mode 100644 index 0000000000..9c3b76d556 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeType.java @@ -0,0 +1,71 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import org.openecomp.sdc.be.datatypes.elements.*; + +import java.util.List; +import java.util.Map; + +public class NodeType extends ToscaElement{ + + public NodeType() { + super(ToscaElementTypeEnum.NODE_TYPE); + } + + private List derivedFrom; + private List derivedList; + private Map attributes; + private Map interfaceArtifacts; + + public List getDerivedList() { + return derivedList; + } + + public void setDerivedList(List derivedList) { + this.derivedList = derivedList; + } + + public List getDerivedFrom() { + return derivedFrom; + } + + public void setDerivedFrom(List derivedFrom) { + this.derivedFrom = derivedFrom; + } + + public Map getAttributes() { + return attributes; + } + + public void setAttributes(Map attributes) { + this.attributes = attributes; + } + + public Map getInterfaceArtifacts() { + return interfaceArtifacts; + } + + public void setInterfaceArtifacts(Map interfaceArtifacts) { + this.interfaceArtifacts = interfaceArtifacts; + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplate.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplate.java new file mode 100644 index 0000000000..a02b07df15 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplate.java @@ -0,0 +1,310 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import org.apache.commons.collections.MapUtils; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; + +import java.util.HashMap; +import java.util.Map; + +public class TopologyTemplate extends ToscaElement{ + + public TopologyTemplate() { + super(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE); + } + private Map inputs; + private Map instInputs; + private Map heatParameters; + private Map instAttributes; + private Map instProperties; + private Map groups; + private Map policies; + private Map instGroups; + private Map serviceApiArtifacts; + private Map forwardingPaths; + private Map compositions; + private Map calculatedCapabilities; + private Map calculatedRequirements; + private Map fullfilledCapabilities; + private Map fullfilledRequirements; + private Map calculatedCapabilitiesProperties; + private Map instDeploymentArtifacts; + private Map instanceArtifacts; + private Map interfaces; + private Map instInterfaces; + private Map componentInstInterfaces; + private Map dataTypes; + + private Map nodeFilterComponents; + //Component Instances External References (instanceId -> ExternalRefsMap) + //----------------------------------------------------------------------- + private Map mapComponentInstancesExternalRefs; + + public Map getMapComponentInstancesExternalRefs() { + return this.mapComponentInstancesExternalRefs; + } + + public void setComponentInstancesExternalRefs(Map mapComponentInstancesExternalRefs) { + this.mapComponentInstancesExternalRefs = mapComponentInstancesExternalRefs; + } + //----------------------------------------------------------------------- + + public Map getInterfaces() { + return interfaces; + } + + public void setInterfaces(Map interfaces) { + this.interfaces = interfaces; + } + + public Map getInstInterfaces() { + return instInterfaces; + } + + public void setInstInterfaces( + Map instInterfaces) { + this.instInterfaces = instInterfaces; + } + + public void addInstInterface(String compId, MapInterfaceInstanceDataDefinition + mapInterfaceInstanceDataDefinition) { + if(MapUtils.isEmpty(this.instInterfaces)) { + this.instInterfaces = new HashMap<>(); + } + + this.instInterfaces.put(compId, mapInterfaceInstanceDataDefinition); + } + + public Map getComponentInstInterfaces() { + return componentInstInterfaces; + } + + public void setComponentInstInterfaces( + Map componentInstInterfaces) { + this.componentInstInterfaces = componentInstInterfaces; + } + + public void addComponentInstanceInterfaceMap(String componentInstanceId, MapInterfaceDataDefinition + mapInterfaceDataDefinition) { + if(MapUtils.isEmpty(this.componentInstInterfaces)) { + this.componentInstInterfaces = new HashMap<>(); + } + + this.componentInstInterfaces.put(componentInstanceId, mapInterfaceDataDefinition); + } + + + public Map getInputs() { + return inputs; + } + public void setInputs(Map inputs) { + this.inputs = inputs; + } + public Map getInstInputs() { + return instInputs; + } + public void setInstInputs(Map instInputs) { + this.instInputs = instInputs; + } + public Map getHeatParameters() { + return heatParameters; + } + public void setHeatParameters(Map heatParameters) { + this.heatParameters = heatParameters; + } + public Map getInstAttributes() { + return instAttributes; + } + public void setInstAttributes(Map instAttributes) { + this.instAttributes = instAttributes; + } + public Map getInstProperties() { + return instProperties; + } + public void setInstProperties(Map instProperties) { + this.instProperties = instProperties; + } + public Map getGroups() { + return groups; + } + public void setGroups(Map groups) { + this.groups = groups; + } + public Map getPolicies() { + return policies; + } + public void setPolicies(Map policies) { + this.policies = policies; + } + public Map getInstGroups() { + return instGroups; + } + public void setInstGroups(Map instGroups) { + this.instGroups = instGroups; + } + public Map getServiceApiArtifacts() { + return serviceApiArtifacts; + } + public void setServiceApiArtifacts(Map serviceApiArtifacts) { + this.serviceApiArtifacts = serviceApiArtifacts; + } + public Map getCompositions() { + return compositions; + } + public void setCompositions(Map compositions) { + this.compositions = compositions; + } + public Map getCalculatedCapabilities() { + return calculatedCapabilities; + } + public void setCalculatedCapabilities(Map calculatedCapabilities) { + this.calculatedCapabilities = calculatedCapabilities; + } + public Map getCalculatedRequirements() { + return calculatedRequirements; + } + public void setCalculatedRequirements(Map calculatedRequirements) { + this.calculatedRequirements = calculatedRequirements; + } + public Map getFullfilledCapabilities() { + return fullfilledCapabilities; + } + public void setFullfilledCapabilities(Map fullfilledCapabilities) { + this.fullfilledCapabilities = fullfilledCapabilities; + } + public Map getFullfilledRequirements() { + return fullfilledRequirements; + } + public void setFullfilledRequirements(Map fullfilledRequirements) { + this.fullfilledRequirements = fullfilledRequirements; + } + + public Map getInstDeploymentArtifacts() { + return instDeploymentArtifacts; + } + public void setInstDeploymentArtifacts(Map instDeploymentArtifacts) { + this.instDeploymentArtifacts = instDeploymentArtifacts; + } + + public Map getCalculatedCapabilitiesProperties() { + return calculatedCapabilitiesProperties; + } + public void setCalculatedCapabilitiesProperties(Map calculatedCapabilitiesProperties) { + this.calculatedCapabilitiesProperties = calculatedCapabilitiesProperties; + } + + public Map getInstanceArtifacts() { + return instanceArtifacts; + } + public void setInstanceArtifacts(Map instanceArtifacts) { + this.instanceArtifacts = instanceArtifacts; + } + + public Map getForwardingPaths() { + return forwardingPaths; + } + + public void setForwardingPaths(Map forwardingPaths) { + this.forwardingPaths = forwardingPaths; + } + + public Map getNodeFilterComponents() { + return nodeFilterComponents; + } + + public void setNodeFilterComponents(Map nodeFilters) { + this.nodeFilterComponents = nodeFilters; + } + + /** + * Gets data types. + * @return Current data types. + */ + public Map getDataTypes() { + return dataTypes; + } + + /** + * Sets data types. + * @param dataTypes New data types. + */ + public void setDataTypes(Map dataTypes) { + this.dataTypes = dataTypes; + } + + /** + * Adds component instance to composition of topology template + * Note that component instance will be overrided in case if the topology template already contains a component instance with the same name + * @param componentInstance + */ + public void addComponentInstance(ComponentInstanceDataDefinition componentInstance){ + if(getCompositions() == null){ + compositions = new HashMap<>(); + } + if(MapUtils.isEmpty(getCompositions())){ + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition()); + } + if(MapUtils.isEmpty(getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances())){ + getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(new HashMap<>()); + } + getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances().put(componentInstance.getUniqueId(), componentInstance); + } + /** + * Returns map of component instances from composition + * @return + */ + public Map getComponentInstances() { + Map instances = null; + if(getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){ + instances = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances(); + } + return instances; + } + + + /** + * Sets map of component instances to composition of topology template + * Note that component instances will be overrided in case if the topology template already contains a component instances + * @param instances + */ + public void setComponentInstances(Map instances) { + if(getCompositions() == null){ + compositions = new HashMap<>(); + } + if(MapUtils.isEmpty(getCompositions())){ + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition()); + } + getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(instances); + } + public Map getRelations() { + Map relations = null; + if( getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){ + relations = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getRelations(); + } + return relations; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElement.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElement.java new file mode 100644 index 0000000000..7685d1c348 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElement.java @@ -0,0 +1,344 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation; +import org.slf4j.MDC; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +public abstract class ToscaElement { + + protected Map metadata; + protected List categories; + protected Map toscaArtifacts; + private Map artifacts; + private Map deploymentArtifacts; + private Map additionalInformation; + private Map properties; + private Map capabilities; + private Map capabiltiesProperties; + private Map requirements; + + protected ToscaElementTypeEnum toscaType; + // User + private String creatorUserId; + private String creatorFullName; + private String lastUpdaterUserId; + private String lastUpdaterFullName; + + private Map allVersions; + + public ToscaElement(ToscaElementTypeEnum toscaType){ + this.toscaType = toscaType; + } + + public Map getMetadata() { + return metadata; + } + + public void setMetadata(Map metadata) { + this.metadata = metadata; + } + + public List getCategories() { + return categories; + } + + public void setCategories(List categories) { + this.categories = categories; + } + public Map getToscaArtifacts() { + return toscaArtifacts; + } + + public void setToscaArtifacts(Map toscaArtifacts) { + this.toscaArtifacts = toscaArtifacts; + } + + public ToscaElementTypeEnum getToscaType() { + return toscaType; + } + + public void setToscaType(ToscaElementTypeEnum toscaType) { + this.toscaType = toscaType; + } + public Map getArtifacts() { + return artifacts; + } + + public void setArtifacts(Map artifacts) { + this.artifacts = artifacts; + } + + public Map getDeploymentArtifacts() { + return deploymentArtifacts; + } + + public void setDeploymentArtifacts(Map deploymentArtifacts) { + this.deploymentArtifacts = deploymentArtifacts; + } + public Map getAdditionalInformation() { + return additionalInformation; + } + public void setAdditionalInformation(Map additionalInformation) { + this.additionalInformation = additionalInformation; + } + public Map getProperties() { + return properties; + } + public void setProperties(Map properties) { + this.properties = properties; + } + + public Map getAllVersions() { + return allVersions; + } + + public void setAllVersions(Map allVersions) { + this.allVersions = allVersions; + } + + public Map getCapabilities() { + return capabilities; + } + + public void setCapabilities(Map capabilities) { + this.capabilities = capabilities; + } + + public Map getRequirements() { + return requirements; + } + + public void setRequirements(Map requirements) { + this.requirements = requirements; + } + + public Map getCapabilitiesProperties() { + return capabiltiesProperties; + } + + public void setCapabilitiesProperties(Map capabiltiesProperties) { + this.capabiltiesProperties = capabiltiesProperties; + } + + // metadata properties + // ---------------------------- + public Object getMetadataValue(JsonPresentationFields name) { + return getMetadataValueOrDefault(name, null); + } + + public Object getMetadataValueOrDefault(JsonPresentationFields name, Object defaultVal) { + if (metadata != null) { + return metadata.getOrDefault(name.getPresentation(), defaultVal); + } + return null; + } + + public void setMetadataValue(JsonPresentationFields name, Object value) { + if (metadata == null) { + metadata = new HashMap<>(); + } + metadata.put(name.getPresentation(), value); + + } + // -------------------- + public String getUUID() { + return (String) getMetadataValue(JsonPresentationFields.UUID); + } + + public void setUUID(String uuid) { + setMetadataValue(JsonPresentationFields.UUID, uuid); + } + + public String getVersion() { + return (String) getMetadataValue(JsonPresentationFields.VERSION); + } + + public String getNormalizedName() { + return (String) getMetadataValue(JsonPresentationFields.NORMALIZED_NAME); + } + + public void setNormalizedName(String normaliseComponentName) { + setMetadataValue(JsonPresentationFields.NORMALIZED_NAME, normaliseComponentName); + } + + public String getName() { + return (String) getMetadataValue(JsonPresentationFields.NAME); + } + + public String getSystemName() { + return (String) getMetadataValue(JsonPresentationFields.SYSTEM_NAME); + } + public void setSystemName(String systemName) { + setMetadataValue(JsonPresentationFields.SYSTEM_NAME, systemName); + } + + public void setLifecycleState(LifecycleStateEnum state) { + if(state != null) + setMetadataValue(JsonPresentationFields.LIFECYCLE_STATE, state.name()); + } + + public LifecycleStateEnum getLifecycleState() { + return LifecycleStateEnum.findState( (String) getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); + } + + public Long getCreationDate() { + return (Long) getMetadataValue(JsonPresentationFields.CREATION_DATE); + } + + public void setCreationDate(Long currentDate) { + setMetadataValue(JsonPresentationFields.CREATION_DATE, currentDate); + } + + public void setLastUpdateDate(Long currentDate) { + setMetadataValue(JsonPresentationFields.LAST_UPDATE_DATE, currentDate); + } + public Long getLastUpdateDate() { + return (Long) getMetadataValue(JsonPresentationFields.LAST_UPDATE_DATE); + } + + public String getUniqueId() { + return (String) getMetadataValue(JsonPresentationFields.UNIQUE_ID); + } + public void setUniqueId(String uniqueId) { + setMetadataValue(JsonPresentationFields.UNIQUE_ID, uniqueId); + } + + public void setHighestVersion(Boolean isHighest) { + setMetadataValue(JsonPresentationFields.HIGHEST_VERSION, isHighest); + + } + public Boolean isHighestVersion() { + return (Boolean) getMetadataValue(JsonPresentationFields.HIGHEST_VERSION); + + } + public ResourceTypeEnum getResourceType() { + String resourceType = (String) getMetadataValue(JsonPresentationFields.RESOURCE_TYPE); + return resourceType != null ? ResourceTypeEnum.valueOf(resourceType) : null; + } + + public void setResourceType(ResourceTypeEnum resourceType) { + if(resourceType != null) + setMetadataValue(JsonPresentationFields.RESOURCE_TYPE, resourceType.name()); + } + + public ComponentTypeEnum getComponentType() { + return ComponentTypeEnum.valueOf((String) getMetadataValue(JsonPresentationFields.COMPONENT_TYPE)); + } + + public void setComponentType(ComponentTypeEnum componentType) { + if(componentType != null) + setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, componentType.name()); + } + + public String getDerivedFromGenericType(){ + return (String) getMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_TYPE); + } + + public void setDerivedFromGenericType(String derivedFromGenericType){ + setMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_TYPE, derivedFromGenericType); + } + + public String getDerivedFromGenericVersion(){ + return (String) getMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_VERSION); + } + + public void setDerivedFromGenericVersion(String derivedFromGenericVersion){ + setMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_VERSION, derivedFromGenericVersion); + } + + public Boolean isArchived() { return (Boolean) getMetadataValue(JsonPresentationFields.IS_ARCHIVED); } + + public void setArchived(Boolean archived) { setMetadataValue(JsonPresentationFields.IS_ARCHIVED, archived); } + + public Long getArchiveTime() { + Object archiveTime = getMetadataValue(JsonPresentationFields.ARCHIVE_TIME); + if (archiveTime instanceof Integer){ + return new Long((Integer)getMetadataValue(JsonPresentationFields.ARCHIVE_TIME)); + } + return (Long)archiveTime; + } + + public void setArchiveTime(Long archiveTime) { setMetadataValue(JsonPresentationFields.ARCHIVE_TIME, archiveTime); } + + public Boolean isVspArchived() { return (Boolean) getMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED); } + + public void setVspArchived(Boolean vspArchived) { setMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED, vspArchived); } + + public String getCreatorUserId() { + return creatorUserId; + } + + public void setCreatorUserId(String creatorUserId) { + this.creatorUserId = creatorUserId; + } + + public String getCreatorFullName() { + return creatorFullName; + } + + public void setCreatorFullName(String creatorFullName) { + this.creatorFullName = creatorFullName; + } + + public String getLastUpdaterUserId() { + return lastUpdaterUserId; + } + + public void setLastUpdaterUserId(String lastUpdaterUserId) { + this.lastUpdaterUserId = lastUpdaterUserId; + } + + public String getLastUpdaterFullName() { + return lastUpdaterFullName; + } + + public void setLastUpdaterFullName(String lastUpdaterFullName) { + this.lastUpdaterFullName = lastUpdaterFullName; + } + + public void generateUUID() { + String prevUUID = getUUID(); + String version = getVersion(); + if ((prevUUID == null && NodeTypeOperation.uuidNormativeNewVersion.matcher(version).matches()) || NodeTypeOperation.uuidNewVersion.matcher(version).matches()) { + UUID uuid = UUID.randomUUID(); + setUUID(uuid.toString()); + MDC.put("serviceInstanceID", uuid.toString()); + } + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnum.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnum.java new file mode 100644 index 0000000000..1e3620ba14 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnum.java @@ -0,0 +1,49 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; + +public enum ToscaElementTypeEnum { + NODE_TYPE("node_type"), + TOPOLOGY_TEMPLATE("topology_template"); + + String value; + private ToscaElementTypeEnum(String value){ + this.value = value; + } + + public static VertexTypeEnum getVertexTypeByToscaType(ToscaElementTypeEnum toscaType ){ + switch ( toscaType ){ + case NODE_TYPE : + return VertexTypeEnum.NODE_TYPE; + case TOPOLOGY_TEMPLATE : + return VertexTypeEnum.TOPOLOGY_TEMPLATE; + default : + return null; + } + } + + public String getValue() { + return value; + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnum.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnum.java new file mode 100644 index 0000000000..308f2db445 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnum.java @@ -0,0 +1,42 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.enums; + +public enum JsonConstantKeysEnum { + + COMPOSITION("composition"), + CAPABILITIES("capabilities"), + REQUIREMENTS("requirements"), + PROPERTIES("properties"), + INPUTS("inputs"), + GROUPS("groups"), + INSTANCE_PROPERIES("instanceProperties"); + + private String value; + + private JsonConstantKeysEnum(String value) { + this.value = value; + } + + public String getValue() { + return value; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperation.java new file mode 100644 index 0000000000..3f2b41e3b5 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperation.java @@ -0,0 +1,292 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.*; +import java.util.stream.Collectors; + +import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArchiveOperation.Action.ARCHIVE; +import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArchiveOperation.Action.RESTORE; + +/** + * Created by yavivi on 25/03/2018. + */ +@Component +public class ArchiveOperation extends BaseOperation { + + private static final Logger log = Logger.getLogger(ArchiveOperation.class.getName()); + + @Autowired + private IGraphLockOperation graphLockOperation; + + public enum Action { + ARCHIVE, RESTORE; + } + + public ArchiveOperation(JanusGraphDao janusGraphDao, IGraphLockOperation graphLockOperation){ + this.janusGraphDao = janusGraphDao; + this.graphLockOperation = graphLockOperation; + } + + public Either, ActionStatus> archiveComponent(String componentId) { + final Either vertexResult = this.janusGraphDao.getVertexById(componentId); + if (vertexResult.isLeft()){ + return doAction(ARCHIVE, vertexResult.left().value()); + } else { + return Either.right(onError(ARCHIVE.name(), componentId, vertexResult.right().value())); + } + } + + public Either, ActionStatus> restoreComponent(String componentId) { + final Either vertexResult = this.janusGraphDao.getVertexById(componentId); + if (vertexResult.isLeft()){ + return doAction(RESTORE, vertexResult.left().value()); + } else { + return Either.right(onError(RESTORE.name(), componentId, vertexResult.right().value())); + } + } + + public ActionStatus onVspRestored(String csarId){ + return onVspStateChanged(RESTORE, csarId); + } + + public ActionStatus onVspArchived(String csarId){ + return onVspStateChanged(ARCHIVE, csarId); + } + + private ActionStatus onVspStateChanged(Action action, String csarId) { + Map props = new HashMap<>(); + props.put(GraphPropertyEnum.CSAR_UUID, csarId); + Either, JanusGraphOperationStatus> vfsE = janusGraphDao + .getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props); + return vfsE.either(vList -> setVspArchived(action, vList), s -> onError("VSP_"+action.name(), csarId, s)); + } + + private ActionStatus setVspArchived(Action action, List vList) { + if (!vList.isEmpty()) { + //Find & Lock the highest version component + GraphVertex highestVersion = this.getHighestVersionFrom(vList.get(0)); + StorageOperationStatus lockStatus = this.graphLockOperation.lockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); + if (lockStatus != StorageOperationStatus.OK){ + return onError(action.name(), highestVersion.getUniqueId(), JanusGraphOperationStatus.ALREADY_LOCKED); + } + + try { + //Set isVspArchived flag + for (GraphVertex v : vList) { + boolean val = action == ARCHIVE ? true : false; + v.setJsonMetadataField(JsonPresentationFields.IS_VSP_ARCHIVED, val); + v.addMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED, val); + janusGraphDao.updateVertex(v); + } + return commitAndCheck("VSP_"+action.name(), vList.toString()); + } finally { + this.graphLockOperation.unlockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); + } + + } + return ActionStatus.OK; + } + + public List setArchivedOriginsFlagInComponentInstances(GraphVertex compositionService) { + List ciUidsWithArchivedOrigins = new LinkedList(); + Either, JanusGraphOperationStatus> instanceOfVerticesE = janusGraphDao + .getChildrenVertecies(compositionService, EdgeLabelEnum.INSTANCE_OF, JsonParseFlagEnum.NoParse); + Either, JanusGraphOperationStatus> proxyOfVerticesE = janusGraphDao + .getChildrenVertecies(compositionService, EdgeLabelEnum.PROXY_OF, JsonParseFlagEnum.NoParse); + + List all = new LinkedList<>(); + if (instanceOfVerticesE.isLeft()){ + all.addAll(instanceOfVerticesE.left().value()); + } + if (proxyOfVerticesE.isLeft()){ + all.addAll(proxyOfVerticesE.left().value()); + } + + List archivedOrigins = all.stream().filter(v -> Boolean.TRUE.equals(v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED))).collect(Collectors.toList()); + List archivedOriginsUids = archivedOrigins.stream().map(GraphVertex::getUniqueId).collect(Collectors.toList()); + + Map compositionsJson = (Map) compositionService.getJson(); + + if (compositionsJson != null) { + CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + if (composition != null) { + + //Get all component instances from composition + Map componentInstances = composition.getComponentInstances(); + + //Extract component instances uids that has archived origins + ciUidsWithArchivedOrigins = componentInstances. + values(). + stream(). + //filter CIs whose origins are marked as archived (componentUid is in archivedOriginsUids) the second condition handles the PROXY_OF case) + filter(ci -> archivedOriginsUids.contains(ci.getComponentUid()) || archivedOriginsUids.contains(ci.getToscaPresentationValue(JsonPresentationFields.CI_SOURCE_MODEL_UID))). + map(ComponentInstanceDataDefinition::getUniqueId).collect(Collectors.toList()); + + //set archived origins flag + componentInstances. + values(). + stream(). + filter(ci -> archivedOriginsUids.contains(ci.getComponentUid()) || archivedOriginsUids.contains(ci.getToscaPresentationValue(JsonPresentationFields.CI_SOURCE_MODEL_UID))). + forEach( ci -> ci.setOriginArchived(true)); + + } + } + + return ciUidsWithArchivedOrigins; + } + + private Either, ActionStatus> doAction(Action action, GraphVertex componentVertex){ + + GraphVertex highestVersion = this.getHighestVersionFrom(componentVertex); + + if (action.equals(ARCHIVE) && isInCheckoutState(highestVersion)) { + return Either.right(ActionStatus.INVALID_SERVICE_STATE); + } + + //Lock the Highest Version + StorageOperationStatus lockStatus = this.graphLockOperation.lockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); + if (lockStatus != StorageOperationStatus.OK){ + return Either.right(onError(action.name(), componentVertex.getUniqueId(), JanusGraphOperationStatus.ALREADY_LOCKED)); + } + + //Refetch latest version with full parsing + highestVersion = this.janusGraphDao + .getVertexById(highestVersion.getUniqueId(), JsonParseFlagEnum.ParseAll).left().value(); + + try { + //Get Catalog and Archive Roots + GraphVertex catalogRoot = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT).left().value(); + GraphVertex archiveRoot = janusGraphDao.getVertexByLabel(VertexTypeEnum.ARCHIVE_ROOT).left().value(); + + if (action == ARCHIVE) { + archiveEdges(catalogRoot, archiveRoot, highestVersion); + } else if (action == RESTORE) { + restoreEdges(catalogRoot, archiveRoot, highestVersion); + } + setPropertiesByAction(highestVersion, action); + janusGraphDao.updateVertex(highestVersion); + + List affectedComponentIds = handleParents(highestVersion, catalogRoot, archiveRoot, action); + ActionStatus sc = commitAndCheck(action.name(), highestVersion.getUniqueId()); + return sc == ActionStatus.OK ? Either.left(affectedComponentIds) : Either.right(sc); + } finally { + this.graphLockOperation.unlockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); + } + } + + private ActionStatus commitAndCheck(String action, String componentId) { + JanusGraphOperationStatus status = janusGraphDao.commit(); + if (!status.equals(JanusGraphOperationStatus.OK)){ + return onError(action, componentId, status); + } + return ActionStatus.OK; + } + + private boolean isInCheckoutState(GraphVertex v) { + if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name().equals(v.getMetadataProperty(GraphPropertyEnum.STATE))){ + return true; + } + return false; + } + + /** + * Walks on children until highest version is reached + * @param v + * @return + */ + private GraphVertex getHighestVersionFrom(GraphVertex v) { + Either childVertexE = janusGraphDao + .getChildVertex(v, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + GraphVertex highestVersionVertex = v; + + while (childVertexE.isLeft()) { + highestVersionVertex = childVertexE.left().value(); + childVertexE = janusGraphDao + .getChildVertex(highestVersionVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + } + return highestVersionVertex; + } + + private boolean isHighestVersion(GraphVertex v){ + Boolean highest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + return highest != null && highest; + } + + private List handleParents(GraphVertex v, GraphVertex catalogRoot, GraphVertex archiveRoot, Action action) { + Either parentVertexE = janusGraphDao + .getParentVertex(v, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); + List affectedCompIds = new ArrayList(); + affectedCompIds.add(v.getUniqueId()); + + while (parentVertexE.isLeft()){ + GraphVertex cv = parentVertexE.left().value(); + affectedCompIds.add(cv.getUniqueId()); + boolean isHighestVersion = isHighestVersion(cv); + if (isHighestVersion){ + if (action == ARCHIVE) { + archiveEdges(catalogRoot, archiveRoot, cv); + } else { + restoreEdges(catalogRoot, archiveRoot, cv); + } + } + setPropertiesByAction(cv, action); + janusGraphDao.updateVertex(cv); + parentVertexE = janusGraphDao + .getParentVertex(cv, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); + } + return affectedCompIds; + } + + private void archiveEdges(GraphVertex catalogRoot, GraphVertex archiveRoot, GraphVertex v) { + janusGraphDao.deleteAllEdges(catalogRoot, v, EdgeLabelEnum.CATALOG_ELEMENT); + janusGraphDao.createEdge(archiveRoot, v, EdgeLabelEnum.ARCHIVE_ELEMENT, null); + setPropertiesByAction(v, ARCHIVE); + } + + private void restoreEdges(GraphVertex catalogRoot, GraphVertex archiveRoot, GraphVertex v) { + janusGraphDao.deleteAllEdges(archiveRoot, v, EdgeLabelEnum.ARCHIVE_ELEMENT); + janusGraphDao.createEdge(catalogRoot, v, EdgeLabelEnum.CATALOG_ELEMENT, null); + setPropertiesByAction(v, RESTORE); + } + + private void setPropertiesByAction(GraphVertex v, Action action) { + long now = System.currentTimeMillis(); + + boolean isArchived = action == ARCHIVE ? true : false; + v.addMetadataProperty(GraphPropertyEnum.IS_ARCHIVED, isArchived); + v.addMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME, now); + v.setJsonMetadataField(JsonPresentationFields.IS_ARCHIVED, isArchived); + v.setJsonMetadataField(JsonPresentationFields.ARCHIVE_TIME, now); + } + + private ActionStatus onError(String action, String componentId, JanusGraphOperationStatus s) { + ActionStatus ret = ActionStatus.GENERAL_ERROR; + if (s == JanusGraphOperationStatus.NOT_FOUND){ + ret = ActionStatus.RESOURCE_NOT_FOUND; + } else if (s == JanusGraphOperationStatus.ALREADY_LOCKED) { + ret = ActionStatus.COMPONENT_IN_USE; + } + String retCodeVal = ret.name(); + log.error("error occurred when trying to {} {}. Return code is: {}", action, componentId, retCodeVal); + return ret; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperations.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperations.java new file mode 100644 index 0000000000..46617a563d --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperations.java @@ -0,0 +1,760 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.tuple.ImmutableTriple; +import org.apache.commons.lang3.tuple.Triple; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.openecomp.sdc.be.config.BeEcompErrorManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.HeatParameterDefinition; +import org.openecomp.sdc.be.model.InterfaceDefinition; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; +import org.openecomp.sdc.common.api.ArtifactTypeEnum; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.slf4j.MDC; + +import java.util.*; +import java.util.Map.Entry; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("artifacts-operations") + +public class ArtifactsOperations extends BaseOperation { + private static final String FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR = "failed to fetch {} for tosca element with id {}, error {}"; + private static final Logger log = Logger.getLogger(ArtifactsOperations.class.getName()); + + public Either addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, String instanceId) { + + String artifactId = artifactInfo.getUniqueId(); + if (artifactId == null && artifactInfo.getEsId() != null) { + artifactId = artifactInfo.getEsId(); + } + Either status = updateArtifactOnGraph(parentId, artifactInfo, type, artifactId, instanceId, false, false); + if (status.isRight()) { + + log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), parentId, status.right().value()); + BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value())); + return Either.right(status.right().value()); + } else { + + ArtifactDataDefinition artifactData = status.left().value(); + + ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData); + log.debug("The returned ArtifactDefintion is {}", artifactDefResult); + return Either.left(artifactDefResult); + } + + } + + public Either updateArtifactOnResource(ArtifactDefinition artifactInfo, String id, String artifactId, NodeTypeEnum type, String instanceId) { + + Either status = updateArtifactOnGraph(id, artifactInfo, type, artifactId, instanceId, true, false); + if (status.isRight()) { + + log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), id, status.right().value()); + BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value())); + return Either.right(status.right().value()); + } else { + + ArtifactDataDefinition artifactData = status.left().value(); + + ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData); + log.debug("The returned ArtifactDefintion is {}", artifactDefResult); + return Either.left(artifactDefResult); + } + } + + public Either isCloneNeeded(String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum type) { + ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType(); + + Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type); + EdgeLabelEnum edgeLabelEnum = triple.getLeft(); + return super.isCloneNeeded(parentId, edgeLabelEnum); + } + + public Either getArtifactById(String parentId, String id) { + return getArtifactById(parentId, id, null, null); + } + + public Either getArtifactById(String parentId, String id, ComponentTypeEnum componentType, String containerId) { + Either result = null; + ArtifactDataDefinition foundArtifact = null; + if (componentType != null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) { + foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + if (foundArtifact == null) { + foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INSTANCE_ARTIFACTS); + } + } + if (foundArtifact == null) { + foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); + } + if (foundArtifact == null) { + foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.TOSCA_ARTIFACTS); + } + + if (foundArtifact == null) { + foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.ARTIFACTS); + } + + if (foundArtifact == null) { + foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.SERVICE_API_ARTIFACTS); + } + if (foundArtifact == null) { + foundArtifact = findInterfaceArtifact(parentId, id); + + } + + if (foundArtifact == null) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + return result; + } + + ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(null, foundArtifact); + return Either.left(artifactDefResult); + + } + private ArtifactDataDefinition findInterfaceArtifact(String parentId, String id) { + Either, JanusGraphOperationStatus> dataFromGraph = getDataFromGraph(parentId, EdgeLabelEnum.INTERFACE); + if (dataFromGraph.isRight()){ + log.debug("failed to fetch interfaces {} for tosca element with id {}, error {}", id, parentId ,dataFromGraph.right().value()); + return null; + } + + Map interfaceDefinitionMap = dataFromGraph.left().value(); + if(interfaceDefinitionMap == null) { + return null; + } + Collection interfaces = interfaceDefinitionMap.values(); + if (interfaces == null){ + return null; + } + for (InterfaceDataDefinition interfaceDataDefinition : interfaces){ + Map operationsMap = interfaceDataDefinition.getOperations(); + if (operationsMap == null) { + return null; + } + ArtifactDataDefinition implementationArtifact = getArtifactDataDefinition(id, operationsMap); + if (implementationArtifact != null) + return implementationArtifact; + } + return null; + } + + private ArtifactDataDefinition getArtifactDataDefinition(String id, + Map operationsMap) { + for(OperationDataDefinition operationDataDefinition : operationsMap.values()){ + ArtifactDataDefinition implementationArtifact = operationDataDefinition.getImplementation(); + if(implementationArtifact != null){ + String uniqueId = implementationArtifact.getUniqueId(); + if (id.equals(uniqueId)) { + return implementationArtifact; + } + } + } + return null; + } + + + public Either removeArifactFromResource(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { + Either status = removeArtifactOnGraph(id, artifactId, type, deleteMandatoryArtifact); + + if (status.isRight()) { + + log.debug("Failed to delete artifact {} of resource {}", artifactId, id); + + BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("Delete Artifact", artifactId, String.valueOf(status.right().value())); + return Either.right(status.right().value()); + } else { + + return Either.left(status.left().value()); + } + } + + public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) { + + Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, parentType); + EdgeLabelEnum edgeLabelEnum = triple.getLeft(); + + Either, JanusGraphOperationStatus> foundArtifact = null; + Map resMap = new HashMap<>(); + foundArtifact = getArtifactByLabel(parentId, instanceId, edgeLabelEnum); + if (foundArtifact.isRight()) { + log.debug("Failed to find artifact in component {} with label {} ", parentId, edgeLabelEnum); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(foundArtifact.right().value())); + } + + resMap.putAll(foundArtifact.left().value()); + + return Either.left(resMap); + } + + /** + * @param parentId the id of the instance container + * @param instanceId the id of the instance of which to return its artifacts + * @return instance and instance deployment artifacts mapped by artifact label name + */ + public Either, StorageOperationStatus> getAllInstanceArtifacts(String parentId, String instanceId) { + Map resMap = new HashMap<>(); + Either, JanusGraphOperationStatus> instArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INSTANCE_ARTIFACTS); + if (instArtifacts.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(instArtifacts.right().value())); + } + Either, JanusGraphOperationStatus> deployInstArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + if (deployInstArtifacts.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deployInstArtifacts.right().value())); + } + resMap.putAll(instArtifacts.left().value()); + resMap.putAll(deployInstArtifacts.left().value()); + return Either.left(convertArtifactMapToArtifactDefinitionMap(resMap)); + } + + public Either, StorageOperationStatus> getArtifacts(String parentId) { + + Either, JanusGraphOperationStatus> foundArtifact = null; + Map resMap = new HashMap<>(); + foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.ARTIFACTS); + if (foundArtifact.isLeft()) { + resMap.putAll(foundArtifact.left().value()); + + } + foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); + if (foundArtifact.isLeft()) { + resMap.putAll(foundArtifact.left().value()); + + } + foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.TOSCA_ARTIFACTS); + if (foundArtifact.isLeft()) { + resMap.putAll(foundArtifact.left().value()); + + } + + return Either.left(resMap); + + } + + public Either removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { + + Either artifactData = this.getArtifactById(id, artifactId); + if (artifactData.isRight()) { + log.debug("Failed to find artifact in component {} with id {} ", id, artifactId); + return Either.right(artifactData.right().value()); + } + ArtifactDataDefinition artifactDefinition = artifactData.left().value(); + boolean isMandatory = false; + if ((artifactDefinition.getMandatory() || artifactDefinition.getServiceApi()) && !deleteMandatoryArtifact) { + // return Either.left(artifactData.left().value()); + isMandatory = true; + } + + Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactDefinition.getArtifactGroupType(), type); + EdgeLabelEnum edgeLabelEnum = triple.getLeft(); + VertexTypeEnum vertexTypeEnum = triple.getRight(); + + if (!isMandatory) { + StorageOperationStatus status = deleteToscaDataElement(id, edgeLabelEnum, vertexTypeEnum, artifactDefinition.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL); + if (status != StorageOperationStatus.OK) + return Either.right(status); + } + + return Either.left(artifactData.left().value()); + + } + + public void updateUUID(ArtifactDataDefinition artifactData, String oldChecksum, String oldVesrion, boolean isUpdate, EdgeLabelEnum edgeLabel) { + if (oldVesrion == null || oldVesrion.isEmpty()) + oldVesrion = "0"; + + String currentChecksum = artifactData.getArtifactChecksum(); + + if (isUpdate) { + ArtifactTypeEnum type = ArtifactTypeEnum.findType(artifactData.getArtifactType()); + switch (type) { + case HEAT_ENV: + if (edgeLabel == EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS) { + generateUUID(artifactData, oldVesrion); + } else { + updateVersionAndDate(artifactData, oldVesrion); + } + break; + case HEAT: + case HEAT_NET: + case HEAT_VOL: + generateUUID(artifactData, oldVesrion); + break; + default: + if (oldChecksum == null || oldChecksum.isEmpty()) { + if (currentChecksum != null) { + generateUUID(artifactData, oldVesrion); + } + } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) { + generateUUID(artifactData, oldVesrion); + } + break; + } + } else { + if (oldChecksum == null || oldChecksum.isEmpty()) { + if (currentChecksum != null) { + generateUUID(artifactData, oldVesrion); + } + } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) { + generateUUID(artifactData, oldVesrion); + } + } + } + + // @TODO add implementation + + public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType) { + return null; + } + + public Either addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifactHeat, String componentId, NodeTypeEnum parentType, boolean failIfExist, String instanceId) { + artifactHeatEnv.setGeneratedFromId(artifactHeat.getUniqueId()); + return addArifactToComponent(artifactHeatEnv, componentId, parentType, failIfExist, instanceId); + } + + public Either getHeatArtifactByHeatEnvId(String parentId, ArtifactDefinition heatEnv, NodeTypeEnum parentType, String containerId, ComponentTypeEnum componentType) { + String id = heatEnv.getGeneratedFromId(); + ComponentTypeEnum compType; + switch (parentType) { + case ResourceInstance: + compType = ComponentTypeEnum.RESOURCE_INSTANCE; + break; + default: + compType = componentType; + } + return getArtifactById(parentId, id, compType, containerId); + } + + public Either updateHeatEnvArtifact(String id, ArtifactDefinition artifactEnvInfo, String artifactId, String newArtifactId, NodeTypeEnum type, String instanceId) { + + Either, JanusGraphOperationStatus> artifactsEither = getArtifactByLabel(id, instanceId, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); + if (artifactsEither.isRight()) { + log.debug("Failed to find artifacts in component {} with id {} ", id, artifactsEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(artifactsEither.right().value())); + } + + Map artifacts = artifactsEither.left().value(); + List envList = artifacts.values().stream().filter(a -> a.getGeneratedFromId() != null && a.getGeneratedFromId().equals(artifactId)).collect(Collectors.toList()); + if (envList != null && !envList.isEmpty()) { + envList.forEach(a -> { + a.setGeneratedFromId(newArtifactId); + updateArtifactOnResource(a, id, a.getUniqueId(), type, instanceId); + + }); + + } + return Either.left(artifactEnvInfo); + } + + public Either updateHeatEnvPlaceholder(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type) { + return updateArtifactOnResource(artifactInfo, parentId, artifactInfo.getUniqueId(), type, null); + } + + + ///////////////////////////////////////////// private methods //////////////////////////////////////////////////// + + protected ArtifactDefinition convertArtifactDataToArtifactDefinition(ArtifactDefinition artifactInfo, ArtifactDataDefinition artifactDefResult) { + log.debug("The object returned after create property is {}", artifactDefResult); + + ArtifactDefinition propertyDefResult = new ArtifactDefinition(artifactDefResult); + if (artifactInfo != null) + propertyDefResult.setPayload(artifactInfo.getPayloadData()); + + List parameters = new ArrayList<>(); + /* + * StorageOperationStatus heatParametersOfNode = heatParametersOperation.getHeatParametersOfNode(NodeTypeEnum.ArtifactRef, artifactDefResult.getUniqueId().toString(), parameters); if ((heatParametersOfNode.equals(StorageOperationStatus.OK)) + * && !parameters.isEmpty()) { propertyDefResult.setHeatParameters(parameters); } + */ + return propertyDefResult; + } + + private ArtifactDataDefinition getInstanceArtifactByLabelAndId(String parentId, String id, String containerId, EdgeLabelEnum edgeLabelEnum) { + ArtifactDataDefinition foundArtifact = null; + Either, JanusGraphOperationStatus> artifactsEither = getDataFromGraph(containerId, edgeLabelEnum); + if (artifactsEither.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, containerId, artifactsEither.right().value()); + return null; + } + + Map artifacts = artifactsEither.left().value(); + + MapArtifactDataDefinition artifactsPerInstance = artifacts.get(parentId); + if (artifactsPerInstance == null) { + log.debug("failed to fetch artifacts for instance {} in tosca element with id {}, error {}", parentId, containerId, artifactsEither.right().value()); + return null; + } + Optional op = artifactsPerInstance.getMapToscaDataDefinition().values().stream().filter(p -> p.getUniqueId().equals(id)).findAny(); + if (op.isPresent()) { + foundArtifact = op.get(); + } + return foundArtifact; + } + + private ArtifactDataDefinition getArtifactByLabelAndId(String parentId, String id, EdgeLabelEnum edgeLabelEnum) { + ArtifactDataDefinition foundArtifact = null; + Either, JanusGraphOperationStatus> artifactsEither = getDataFromGraph(parentId, edgeLabelEnum); + if (artifactsEither.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value()); + return null; + } + + Map artifacts = artifactsEither.left().value(); + Optional op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(id)).findAny(); + if (op.isPresent()) { + foundArtifact = op.get(); + } + return foundArtifact; + } + + private Either, JanusGraphOperationStatus> getArtifactByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { + Either, JanusGraphOperationStatus> artifactsEither = getArtifactsDataByLabel(parentId, instanceId, edgeLabelEnum); + if (artifactsEither.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value()); + return Either.right(artifactsEither.right().value()); + } + Map artifactDataMap = artifactsEither.left().value(); + return Either.left(convertArtifactMapToArtifactDefinitionMap(artifactDataMap)); + } + + private Either, JanusGraphOperationStatus> getArtifactsDataByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { + return edgeLabelEnum.isInstanceArtifactsLabel() ? getInstanceArtifactsByLabel(parentId, instanceId, edgeLabelEnum) : getDataFromGraph(parentId, edgeLabelEnum); + } + + private Map convertArtifactMapToArtifactDefinitionMap(Map artifactDataMap) { + Map artMap = new HashMap<>(); + if (artifactDataMap != null && !artifactDataMap.isEmpty()) { + artMap = artifactDataMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> convertArtifactDataToArtifactDefinition(null, e.getValue()))); + } + return artMap; + } + + private Either, JanusGraphOperationStatus> getInstanceArtifactsByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { + Either, JanusGraphOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum); + if (resultEither.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, resultEither.right().value()); + return Either.right(resultEither.right().value()); + } + Map mapArtifacts = resultEither.left().value(); + MapArtifactDataDefinition artifactPerInstance = mapArtifacts.get(instanceId); + return artifactPerInstance != null ? Either.left(artifactPerInstance.getMapToscaDataDefinition()) : Either.left(new HashMap<>()); + } + + private Triple getEdgeLabelEnumFromArtifactGroupType(ArtifactGroupTypeEnum groupType, NodeTypeEnum nodeType) { + EdgeLabelEnum edgeLabelEnum; + VertexTypeEnum vertexTypeEnum; + Boolean isDeepElement = false; + /* + * if (nodeType == NodeTypeEnum.ResourceInstance) { edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; isDeepElement = true; } else { + */ + switch (groupType) { + case TOSCA: + edgeLabelEnum = EdgeLabelEnum.TOSCA_ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.TOSCA_ARTIFACTS; + break; + case DEPLOYMENT: + if (nodeType == NodeTypeEnum.ResourceInstance) { + edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; + isDeepElement = true; + } else { + edgeLabelEnum = EdgeLabelEnum.DEPLOYMENT_ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.DEPLOYMENT_ARTIFACTS; + } + break; + case SERVICE_API: + edgeLabelEnum = EdgeLabelEnum.SERVICE_API_ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.SERVICE_API_ARTIFACTS; + break; + default: + if (nodeType == NodeTypeEnum.ResourceInstance) { + edgeLabelEnum = EdgeLabelEnum.INSTANCE_ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.INSTANCE_ARTIFACTS; + isDeepElement = true; + } else { + edgeLabelEnum = EdgeLabelEnum.ARTIFACTS; + vertexTypeEnum = VertexTypeEnum.ARTIFACTS; + } + break; + } + // } + return new ImmutableTriple<>(edgeLabelEnum, isDeepElement, vertexTypeEnum); + + } + + public Either updateArtifactOnGraph(String componentId, ArtifactDefinition artifactInfo, NodeTypeEnum type, String artifactId, String instanceId, boolean isUpdate, boolean isDeletePlaceholder) { + Either res = null; + ArtifactDataDefinition artifactToUpdate = new ArtifactDataDefinition(artifactInfo); + ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType(); + + Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type); + EdgeLabelEnum edgeLabelEnum = triple.getLeft(); + VertexTypeEnum vertexTypeEnum = triple.getRight(); + + Either isNeedToCloneEither = isCloneNeeded(componentId, edgeLabelEnum); + if (isNeedToCloneEither.isRight()) { + log.debug("Failed check is clone needed {}", componentId); + return Either.right(isNeedToCloneEither.right().value()); + + } + boolean isNeedToClone = isNeedToCloneEither.left().value(); + + if (artifactId == null || isNeedToClone) { + String uniqueId; + if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { + uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel()); + } else { + uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel()); + } + artifactToUpdate.setUniqueId(uniqueId); + if (!isDeletePlaceholder) + artifactToUpdate.setEsId(uniqueId); + } else + artifactToUpdate.setUniqueId(artifactId); + + Map artifacts = new HashMap<>(); + Map artifactInst = null; + if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { + + Either, JanusGraphOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum); + + if (artifactsEither.isLeft() && artifactsEither.left().value() != null && !artifactsEither.left().value().isEmpty()) { + artifacts = artifactsEither.left().value(); + if (isNeedToClone && artifacts != null) { + artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); + } + } + } else { + + Either, JanusGraphOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum); + if (artifactsEither.isLeft()) { + artifactInst = artifactsEither.left().value(); + if (isNeedToClone && artifactInst != null) { + artifactInst.values().forEach(ma -> ma.getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE))); + } + MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId); + if (artifatcsOnInstance != null) { + artifacts = artifatcsOnInstance.getMapToscaDataDefinition(); + } + } + } + String oldChecksum = null; + String oldVersion = null; + if (artifacts != null && artifacts.containsKey(artifactInfo.getArtifactLabel())) { + ArtifactDataDefinition oldArtifactData = artifacts.get(artifactInfo.getArtifactLabel()); + oldChecksum = oldArtifactData.getArtifactChecksum(); + oldVersion = oldArtifactData.getArtifactVersion(); + //duplicated flag didn't receive from UI, take from DB + artifactToUpdate.setDuplicated(oldArtifactData.getDuplicated()); + + if (isNeedToClone) + artifactToUpdate.setDuplicated(Boolean.FALSE); + else { + if (artifactToUpdate.getDuplicated()) { + String uniqueId = ""; + if(type != NodeTypeEnum.ResourceInstance) + uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel()); + else + uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel()); + + artifactToUpdate.setUniqueId(uniqueId); + if (!isDeletePlaceholder) + artifactToUpdate.setEsId(uniqueId); + artifactToUpdate.setDuplicated(Boolean.FALSE); + } + } + } + updateUUID(artifactToUpdate, oldChecksum, oldVersion, isUpdate, edgeLabelEnum); + + if (artifactInfo.getPayloadData() == null) { + if (!artifactToUpdate.getMandatory() || artifactToUpdate.getEsId() != null) { + artifactToUpdate.setEsId(artifactToUpdate.getUniqueId()); + } + } else { + if (artifactToUpdate.getEsId() == null) { + artifactToUpdate.setEsId(artifactToUpdate.getUniqueId()); + } + } + + StorageOperationStatus status = StorageOperationStatus.OK; + if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { + List toscaDataList = new ArrayList<>(); + toscaDataList.add(artifactToUpdate); + + if (isNeedToClone && artifacts != null) { + artifacts.values().stream().filter(a -> !a.getArtifactLabel().equals(artifactToUpdate.getArtifactLabel())).forEach(toscaDataList::add); + } + status = updateToscaDataOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, JsonPresentationFields.ARTIFACT_LABEL); + } else { + List toscaDataList = new ArrayList<>(); + toscaDataList.add(artifactToUpdate); + List pathKeys = new ArrayList<>(); + pathKeys.add(instanceId); + if (isNeedToClone) { + MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId); + if (artifatcsOnInstance != null) { + artifacts = artifatcsOnInstance.getMapToscaDataDefinition(); + artifacts.put(artifactToUpdate.getArtifactLabel(), artifactToUpdate); + } + + for (Entry e : artifactInst.entrySet()) { + List toscaDataListPerInst = e.getValue().getMapToscaDataDefinition().values().stream().collect(Collectors.toList()); + List pathKeysPerInst = new ArrayList<>(); + pathKeysPerInst.add(e.getKey()); + status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.ARTIFACT_LABEL); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update atifacts group for instance {} in component {} edge type {} error {}", instanceId, componentId, edgeLabelEnum, status); + res = Either.right(status); + break; + } + } + } else { + status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, pathKeys, JsonPresentationFields.ARTIFACT_LABEL); + } + } + if (status == StorageOperationStatus.OK) + res = Either.left(artifactToUpdate); + else + res = Either.right(status); + return res; + } + + public void generateUUID(ArtifactDataDefinition artifactData, String oldVesrion) { + + UUID uuid = UUID.randomUUID(); + artifactData.setArtifactUUID(uuid.toString()); + MDC.put("serviceInstanceID", uuid.toString()); + updateVersionAndDate(artifactData, oldVesrion); + } + + private void updateVersionAndDate(ArtifactDataDefinition artifactData, String oldVesrion) { + if (artifactData.getArtifactChecksum() != null) { + long time = System.currentTimeMillis(); + artifactData.setPayloadUpdateDate(time); + } + int newVersion = new Integer(oldVesrion).intValue(); + newVersion++; + artifactData.setArtifactVersion(String.valueOf(newVersion)); + } + + public Either removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { + + Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type); + EdgeLabelEnum edgeLabelEnum = triple.getLeft(); + VertexTypeEnum vertexTypeEnum = triple.getRight(); + + if (deleteMandatoryArtifact || !(artifactFromGraph.getMandatory() || artifactFromGraph.getServiceApi())) { + StorageOperationStatus status; + if (triple.getMiddle()) { + List pathKeys = new ArrayList<>(); + pathKeys.add(instanceId); + status = deleteToscaDataDeepElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), pathKeys, JsonPresentationFields.ARTIFACT_LABEL); + } else { + status = deleteToscaDataElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL); + } + if (status != StorageOperationStatus.OK) + return Either.right(status); + } + return Either.left(artifactFromGraph); + + } + + public Either deleteArtifactWithCloningOnGraph(String componentId, ArtifactDefinition artifactToDelete, NodeTypeEnum type, String instanceId, boolean deleteMandatoryArtifact) { + + Either result = null; + Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactToDelete.getArtifactGroupType(), type); + EdgeLabelEnum edgeLabel = triple.getLeft(); + VertexTypeEnum vertexLabel = triple.getRight(); + + Boolean deleteElement = deleteMandatoryArtifact || !(artifactToDelete.getMandatory() || artifactToDelete.getServiceApi()); + Map artifacts = null; + GraphVertex parentVertex = null; + Either, JanusGraphOperationStatus> getArtifactsRes = null; + + Either getToscaElementRes = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", componentId, getToscaElementRes.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value())); + } + if (result == null) { + parentVertex = getToscaElementRes.left().value(); + getArtifactsRes = this.getDataFromGraph(parentVertex, edgeLabel); + if (getArtifactsRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getArtifactsRes.right().value())); + } + } + if (result == null) { + artifacts = getArtifactsRes.left().value(); + if (triple.getMiddle()) { + artifacts.values().forEach(ma -> ((MapArtifactDataDefinition) ma).getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE))); + MapArtifactDataDefinition artifatcsOnInstance = (MapArtifactDataDefinition) artifacts.get(instanceId); + if (artifatcsOnInstance != null && deleteElement) { + artifatcsOnInstance.getMapToscaDataDefinition().remove(artifactToDelete.getArtifactLabel()); + } + } else { + if (deleteElement) { + artifacts.remove(artifactToDelete.getArtifactLabel()); + } + artifacts.values().stream().forEach(a -> ((ArtifactDataDefinition) a).setDuplicated(Boolean.TRUE)); + } + artifactToDelete.setDuplicated(Boolean.TRUE); + } + if (artifacts != null) { + JanusGraphOperationStatus + status = janusGraphDao.deleteEdgeByDirection(parentVertex, Direction.OUT, edgeLabel); + if (status != JanusGraphOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } else if (MapUtils.isNotEmpty(artifacts)) { + Either associateResult = associateElementToData(parentVertex, vertexLabel, edgeLabel, artifacts); + if (associateResult.isRight()) { + result = Either.right(associateResult.right().value()); + } + } + } + if (result == null) { + result = Either.left(artifactToDelete); + } + return result; + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/BaseOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/BaseOperation.java new file mode 100644 index 0000000000..a4fe67eb3f --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/BaseOperation.java @@ -0,0 +1,1518 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.janusgraph.core.JanusGraphVertex; +import org.openecomp.sdc.be.dao.impl.HealingPipelineDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.operations.StorageException; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.springframework.beans.factory.annotation.Autowired; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.stream.Collectors; + +/** + * public abstract class BaseOperation provides base operation functionality and common fields + * + */ +public abstract class BaseOperation { + + private static final String FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS = "Failed remove tosca data vertex of the tosca element {} by label {}. Status is {}. "; + private static final String FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS = "Failed to get child vertex of the tosca element {} by label {}. Status is {}. "; + private static final String FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS = "Failed to get tosca element {} upon adding the properties. Status is {}. "; + private static final Logger log = Logger.getLogger(BaseOperation.class.getName()); + public static final String VF_MODULE = "org.openecomp.groups.VfModule"; + + @Autowired + protected JanusGraphDao janusGraphDao; + + @Autowired + protected NodeTypeOperation nodeTypeOperation; + + @Autowired + protected TopologyTemplateOperation topologyTemplateOperation; + +// @Autowired + protected HealingPipelineDao healingPipelineDao; + + public void setJanusGraphDao(JanusGraphDao janusGraphDao) { + this.janusGraphDao = janusGraphDao; + } + /** + * Returns reference to appropriate toscaTemplateOperation + * + * @param componentType + * @return + */ + public ToscaElementOperation getToscaElementOperation(ComponentTypeEnum componentType) { + ToscaElementOperation operation; + switch (componentType) { + case SERVICE: + case RESOURCE: + operation = topologyTemplateOperation; + break; + default: + operation = nodeTypeOperation; + break; + } + return operation; + } + + /** + * Returns reference to appropriate toscaTemplateOperation + * + * @param toscaElementType + * @return + */ + public ToscaElementOperation getToscaElementOperation(ToscaElementTypeEnum toscaElementType) { + ToscaElementOperation operation; + switch (toscaElementType) { + case TOPOLOGY_TEMPLATE: + operation = topologyTemplateOperation; + break; + case NODE_TYPE: + operation = nodeTypeOperation; + break; + default: + operation = null; + break; + } + return operation; + } + + /** + * Returns reference to appropriate toscaTemplateOperation + * + * @param toscaElementType + * @return + */ + public ToscaElementOperation getToscaElementOperation(VertexTypeEnum toscaElementType) { + ToscaElementOperation operation; + switch (toscaElementType) { + case TOPOLOGY_TEMPLATE: + operation = topologyTemplateOperation; + break; + case NODE_TYPE: + operation = nodeTypeOperation; + break; + default: + operation = null; + break; + } + return operation; + } + /** + * Converts received vertex to User object + * + * @param ownerV + * @return + */ + public User convertToUser(Vertex ownerV) { + User owner = new User(); + owner.setUserId((String) ownerV.property(GraphPropertyEnum.USERID.getProperty()).value()); + VertexProperty property = ownerV.property(GraphPropertyEnum.ROLE.getProperty()); + if(property != null && property.isPresent() ){ + owner.setRole((String) property.value()); + } + + property = ownerV.property(GraphPropertyEnum.FIRST_NAME.getProperty()); + if(property != null && property.isPresent() ){ + owner.setFirstName((String) ownerV.property(GraphPropertyEnum.FIRST_NAME.getProperty()).value()); + } + + property = ownerV.property(GraphPropertyEnum.LAST_NAME.getProperty()); + if( property != null && property.isPresent() ){ + owner.setLastName((String) ownerV.property(GraphPropertyEnum.LAST_NAME.getProperty()).value()); + } + + property = ownerV.property(GraphPropertyEnum.EMAIL.getProperty()); + if( property != null && property.isPresent() ){ + owner.setEmail((String) ownerV.property(GraphPropertyEnum.EMAIL.getProperty()).value()); + } + + property = ownerV.property(GraphPropertyEnum.LAST_LOGIN_TIME.getProperty()); + if( property != null && property.isPresent() ){ + owner.setLastLoginTime((Long) ownerV.property(GraphPropertyEnum.LAST_LOGIN_TIME.getProperty()).value()); + } + return owner; + } + + protected Either, JanusGraphOperationStatus> getDataFromGraph(GraphVertex componentV, EdgeLabelEnum edgelabel) { + Either>, JanusGraphOperationStatus> dataVertex = getDataAndVertexFromGraph(componentV, edgelabel); + if (dataVertex.isRight()) { + return Either.right(dataVertex.right().value()); + } + Map properties = dataVertex.left().value().getRight(); + return Either.left(properties); + } + + @SuppressWarnings("unchecked") + protected Either>, JanusGraphOperationStatus> getDataAndVertexFromGraph(GraphVertex componentV, EdgeLabelEnum edgelabel) { + Either dataVertex = getDataVertex(componentV, edgelabel); + if (dataVertex.isRight()) { + return Either.right(dataVertex.right().value()); + } + GraphVertex propV = dataVertex.left().value(); + Map properties = (Map) propV.getJson(); + Pair> pair = new ImmutablePair<>(propV, properties); + return Either.left(pair); + } + + protected Either getDataVertex(GraphVertex componentV, EdgeLabelEnum edgelabel) { + Either childVertex = janusGraphDao + .getChildVertex(componentV, edgelabel, JsonParseFlagEnum.ParseJson); + if (childVertex.isRight()) { + if (childVertex.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("failed to fetch {} for tosca element with id {}, error {}", edgelabel, componentV.getUniqueId(), childVertex.right().value()); + } + return Either.right(childVertex.right().value()); + } + GraphVertex propV = childVertex.left().value(); + return Either.left(propV); + } + + /** + * Returns tosca data belonging to tosca element specified by uid according received label + * + * @param toscaElementUid + * @param edgelabel + * @return + */ + public Either, JanusGraphOperationStatus> getDataFromGraph(String toscaElementUid, EdgeLabelEnum edgelabel) { + + Either, JanusGraphOperationStatus> result = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", toscaElementUid, status); + result = Either.right(status); + } + if (result == null) { + result = getDataFromGraph(getToscaElementRes.left().value(), edgelabel); + } + return result; + } + + public Either findUserVertex(String userId) { + return janusGraphDao + .getVertexByPropertyAndLabel(GraphPropertyEnum.USERID, userId, VertexTypeEnum.USER, JsonParseFlagEnum.NoParse); + } + + /** + * + * @param elemementId + * @param label + * @return + */ + public Either isCloneNeeded(String elemementId, EdgeLabelEnum label) { + Either vertexById = janusGraphDao.getVertexById(elemementId); + if (vertexById.isRight()) { + log.debug("Failed to fetch element by id {} error {}", elemementId, vertexById.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexById.right().value())); + } + GraphVertex toscaElementVertex = vertexById.left().value(); + Either childVertex = janusGraphDao + .getChildVertex(toscaElementVertex, label, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + if (childVertex.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("failed to fetch {} for tosca element with id {}, error {}", label, toscaElementVertex.getUniqueId(), childVertex.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childVertex.right().value())); + } + return Either.left(Boolean.FALSE); + } + GraphVertex dataVertex = childVertex.left().value(); + Iterator edges = dataVertex.getVertex().edges(Direction.IN, label.name()); + int edgeCount = 0; + while (edges.hasNext()) { + edges.next(); + ++edgeCount; + } + if (edgeCount > 1) { + return Either.left(Boolean.TRUE); + } else { + return Either.left(Boolean.FALSE); + } + } + + protected Either updateOrCopyOnUpdate(GraphVertex dataVertex, GraphVertex toscaElementVertex, EdgeLabelEnum label) { +// healingPipelineDao.setHealingVersion(dataVertex); + Iterator edges = dataVertex.getVertex().edges(Direction.IN, label.name()); + int edgeCount = 0; + Edge edgeToRemove = null; + while (edges.hasNext()) { + Edge edge = edges.next(); + ++edgeCount; + Vertex outVertex = edge.outVertex(); + String outId = (String) janusGraphDao + .getProperty((JanusGraphVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()); + if (toscaElementVertex.getUniqueId().equals(outId)) { + edgeToRemove = edge; + } + } + if (edgeToRemove == null) { + log.debug("No edges {} from vertex {} to vertex {}", label, toscaElementVertex.getUniqueId(), dataVertex.getUniqueId()); + return Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + } + switch (edgeCount) { + case 0: + // error + log.debug("No edges {} to vertex {}", label, dataVertex.getUniqueId()); + return Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + case 1: + // update + log.trace("Only one edge {} to vertex {}. Update vertex", label, dataVertex.getUniqueId()); + return janusGraphDao.updateVertex(dataVertex); + default: + // copy on update + log.trace("More than one edge {} to vertex {}. Need to clone vertex", label, dataVertex.getUniqueId()); + return cloneDataVertex(dataVertex, toscaElementVertex, label, edgeToRemove); + } + } + + private Either cloneDataVertex(GraphVertex dataVertex, GraphVertex toscaElementVertex, EdgeLabelEnum label, Edge edgeToRemove) { + GraphVertex newDataVertex = new GraphVertex(dataVertex.getLabel()); + String id = IdBuilderUtils.generateChildId(toscaElementVertex.getUniqueId(), dataVertex.getLabel()); + newDataVertex.cloneData(dataVertex); + newDataVertex.setUniqueId(id); + + Either createVertex = janusGraphDao.createVertex(newDataVertex); + if (createVertex.isRight()) { + log.debug("Failed to clone data vertex for {} error {}", dataVertex.getUniqueId(), createVertex.right().value()); + return createVertex; + } + newDataVertex = createVertex.left().value(); + JanusGraphOperationStatus + createEdge = janusGraphDao + .createEdge(toscaElementVertex, newDataVertex, label, janusGraphDao.getEdgeProperties(edgeToRemove)); + if (createEdge != JanusGraphOperationStatus.OK) { + log.debug("Failed to associate vertex {} to vertex {}, error {}", toscaElementVertex.getUniqueId(), newDataVertex.getUniqueId(), createEdge); + return Either.right(createEdge); + } + edgeToRemove.remove(); + return Either.left(newDataVertex); + } + + public Either associateElementToData(GraphVertex element, VertexTypeEnum vertexLabel, EdgeLabelEnum edgeLabel, Map data) { + GraphVertex dataV = new GraphVertex(vertexLabel); + String id = IdBuilderUtils.generateChildId(element.getUniqueId(), vertexLabel); + dataV.setUniqueId(id); + dataV.setJson(data); + Either createVertex = janusGraphDao.createVertex(dataV); + if (createVertex.isRight()) { + log.trace("Failed to create {} vertex for type node {}", vertexLabel, element.getUniqueId()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createVertex.right().value())); + } + dataV = createVertex.left().value(); + JanusGraphOperationStatus + createEdgeStatus = janusGraphDao + .createEdge(element.getVertex(), dataV.getVertex(), edgeLabel, new HashMap<>()); + if (createEdgeStatus != JanusGraphOperationStatus.OK) { + log.trace("Failed to create {} vertex for type node {}", vertexLabel, element.getUniqueId()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeStatus)); + } + return Either.left(dataV); + } + + /** + * Adds tosca data element to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return addToscaDataToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + + /** + * Adds tosca data deep element to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataDeepElementToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, + JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return addToscaDataDeepElementsToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + + /** + * Converts recieved map of tosca data deep elements to list and adds it to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataMap + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataDeepElementsToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaDataMap, List pathKeys, + JsonPresentationFields mapKeyField) { + + if (toscaDataMap != null) { + return addToscaDataDeepElementsToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataMap.values().stream().collect(Collectors.toList()), pathKeys, mapKeyField); + } + return StorageOperationStatus.OK; + } + + /** + * Adds list of tosca data deep elements to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataDeepElementsToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, + JsonPresentationFields mapKeyField) { + + return updateOrAddToscaDataDeepElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField, false); + } + + /** + * Updates list of tosca data elements of tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return updateToscaDataOfToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + + /** + * Updates tosca data deep element of tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataDeepElementOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, + JsonPresentationFields mapKeyField) { + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return updateToscaDataDeepElementsOfToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + + /** + * Updates tosca data deep elements of tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataDeepElementsOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, + JsonPresentationFields mapKeyField) { + + return updateOrAddToscaDataDeepElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField, true); + } + + /** + * Adds tosca data element to tosca element with specified uid according received labels + * + * @param toscaElementUid + * @param toscaData + * @param edgeLabel + * @param vertexLabel + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return addToscaDataToToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + + /** + * Adds tosca data deep element to tosca element with specified uid according received labels + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataDeepElementToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, + JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return addToscaDataDeepElementsToToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + + public StorageOperationStatus updateToscaDataDeepElementOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, + JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return updateToscaDataDeepElementsOfToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + + public StorageOperationStatus updateToscaDataDeepElementsOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, + JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { + statusRes = updateToscaDataDeepElementsOfToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + StorageOperationStatus overrideToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, Map toscaData) { + return janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse) + .left() + .bind(graphVertex -> overrideToscaElementData(graphVertex, toscaData, edgeLabel)) + .either(graphVertex -> StorageOperationStatus.OK, + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + private Either overrideToscaElementData(GraphVertex toscaElement, Map toscaData, EdgeLabelEnum edgeLabelEnum) { + return janusGraphDao.getChildVertex(toscaElement, edgeLabelEnum, JsonParseFlagEnum.ParseJson) + .left() + .bind(dataVertex -> overrideToscaElementData(dataVertex, toscaElement, toscaData, edgeLabelEnum)) + .right() + .map(err -> logAndReturn(err, "failed to override tosca data for element {} of type {}. status: {}", toscaElement.getUniqueId(), edgeLabelEnum, err)); + } + + private Either overrideToscaElementData(GraphVertex dataElement, GraphVertex toscaElement, Map toscaData, EdgeLabelEnum edgeLabelEnum) { + dataElement.setJson(toscaData); + return updateOrCopyOnUpdate(dataElement, toscaElement, edgeLabelEnum); + } + + /** + * Adds list of tosca data deep elements to tosca element with specified uid according received labels + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataDeepElementsToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, + JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { + statusRes = addToscaDataDeepElementsToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + public StorageOperationStatus deleteToscaDataDeepElementsBlockOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String key) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null) { + statusRes = deleteToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, key); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + public StorageOperationStatus deleteToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String key) { + + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight()) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + toscaDataVertex = toscaDataVertexRes.left().value(); + result = deleteDeepElementsBlock(toscaDataVertex, key); + } + if (result == null) { + Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); + if (updateOrCopyRes.isRight()) { + JanusGraphOperationStatus status = updateOrCopyRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca data block {} from the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + @SuppressWarnings("rawtypes") + public StorageOperationStatus addToscaDataDeepElementsBlockToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, MapDataDefinition toscaDataMap, String key) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null && toscaDataMap != null) { + statusRes = addToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataMap, key); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + @SuppressWarnings("rawtypes") + public StorageOperationStatus addToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, MapDataDefinition toscaDataMap, String key) { + + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null && toscaDataVertexRes.isLeft()) { + toscaDataVertex = toscaDataVertexRes.left().value(); + result = addDeepElementsBlock(toscaDataVertex, toscaDataMap, key); + + } + if (result == null) { + if (toscaDataVertex != null) { + Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); + if (updateOrCopyRes.isRight()) { + JanusGraphOperationStatus status = updateOrCopyRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data {} to the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } else { + Map data = new HashMap<>(); + data.put(key, toscaDataMap); + Either createRes = associateElementToData(toscaElement, vertexLabel, edgeLabel, data); + if (createRes.isRight()) { + StorageOperationStatus status = createRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to assosiate tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); + result = status; + } + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + /** + * + * @param toscaElementId the id of the tosca element data container + * @param edgeLabel the edge label of the data type to update + * @param toscaDataMap the data to update + * @param key the key in the json object where the map object block resides + * @return the status of the update operation + */ + public StorageOperationStatus updateToscaDataDeepElementsBlockToToscaElement(String toscaElementId, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { + return janusGraphDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse) + .either(toscaElement -> updateToscaDataDeepElementsBlockToToscaElement(toscaElement, edgeLabel, toscaDataMap, key), + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + private StorageOperationStatus updateToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { + return janusGraphDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson) + .left() + .bind(dataVertex -> updateToscaDataDeepElementsBlockToToscaElement(toscaElement, dataVertex, edgeLabel, toscaDataMap, key)) + .either(updatedVertex -> StorageOperationStatus.OK, + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + private Either updateToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, GraphVertex dataElement, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { + Map mapToscaDataDefinition = toscaDataMap.getMapToscaDataDefinition(); + updateDeepElements(dataElement, mapToscaDataDefinition, Collections.singletonList(key)); + return updateOrCopyOnUpdate(dataElement, toscaElement, edgeLabel) + .right() + .map(err -> logAndReturn(err, "failed while trying to update data vertex from tosca element {}, of type {} . status {}", toscaElement.getUniqueId(), edgeLabel, err)); + } + + /** + * Updates tosca data element of tosca element by specified uid according received labels + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param toscaData + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { + + List toscaDataList = new ArrayList<>(); + toscaDataList.add(toscaData); + return updateToscaDataOfToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + + /** + * Updates list of tosca data elements belonging to tosca element with specified uid according received labels + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { + statusRes = updateToscaDataOfToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + /** + * Adds list of tosca data elements to tosca element with specified uid according received labels + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = null; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { + statusRes = addToscaDataToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, mapKeyField); + } + if (statusRes == null) { + statusRes = StorageOperationStatus.OK; + } + return statusRes; + } + + /** + * Converts recieved map of tosca data elements to list and adds it to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataMap + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaDataMap, JsonPresentationFields mapKeyField) { + + return addToscaDataToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataMap.values().stream().collect(Collectors.toList()), mapKeyField); + } + + /** + * Adds list of tosca data elements to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param mapKeyField + * @return + */ + public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { + + return updateOrAddToscaData(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField, false); + } + + /** + * Updates list of tosca data elements belonging to tosca element according received labels + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param toscaDataList + * @param mapKeyField + * @return + */ + public StorageOperationStatus updateToscaDataOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { + + return updateOrAddToscaData(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField, true); + } + + public boolean hasEdgeOfType(GraphVertex toscaElement, EdgeLabelEnum edgeLabel) { + Either vertex = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + return vertex.isLeft(); + } + + @SuppressWarnings("unchecked") + private StorageOperationStatus updateOrAddToscaData(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField, boolean isUpdate) { + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Map existingToscaDataMap = null; + Either, StorageOperationStatus> validateRes = null; + Map mergedToscaDataMap; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + if (toscaDataVertexRes.isLeft()) { + toscaDataVertex = toscaDataVertexRes.left().value(); + existingToscaDataMap = (Map) toscaDataVertex.getJson(); + } + + validateRes = validateMergeToscaData(toscaElement, toscaDataList, mapKeyField, existingToscaDataMap, isUpdate); + if (validateRes.isRight()) { + result = validateRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed validate tosca data upon adding to tosca element {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); + } + } + if (result == null) { + mergedToscaDataMap = validateRes.left().value(); + result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, mergedToscaDataMap); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + + } + + @SuppressWarnings("unchecked") + public StorageOperationStatus updateFullToscaData(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaData) { + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Map existingToscaDataMap = null; + + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + if (toscaDataVertexRes.isLeft()) { + toscaDataVertex = toscaDataVertexRes.left().value(); + existingToscaDataMap = (Map) toscaDataVertex.getJson(); + } + + + } + if (result == null) { + + result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, toscaData); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private StorageOperationStatus updateOrAddToscaDataDeepElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, + JsonPresentationFields mapKeyField, boolean isUpdate) { + + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Map existingDeepElementsMap = null; + Either, StorageOperationStatus> validateRes = null; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + if (toscaDataVertexRes.isLeft()) { + toscaDataVertex = toscaDataVertexRes.left().value(); + existingDeepElementsMap = getDeepElements(toscaDataVertex, pathKeys); + } + validateRes = validateMergeToscaData(toscaElement, toscaDataList, mapKeyField, existingDeepElementsMap, isUpdate); + if (validateRes.isRight()) { + result = validateRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed validate tosca data upon adding to tosca element {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); + } + } + if (result == null) { + updateDeepElements(toscaDataVertex, validateRes.left().value(), pathKeys); + Map toscaDataToHandle; + if(toscaDataVertex == null){ + toscaDataToHandle = new HashMap<>(); + Map currMap = toscaDataToHandle; + for (int i = 1; i < pathKeys.size()-1; ++i) { + currMap.put(pathKeys.get(i), (K) new MapDataDefinition()); + currMap = (Map) ((MapDataDefinition) currMap).getMapToscaDataDefinition().get(pathKeys.get(i)); + } + toscaDataToHandle.put(pathKeys.get(pathKeys.size()-1), (K) new MapDataDefinition(validateRes.left().value())); + + } else { + toscaDataToHandle = (Map) toscaDataVertex.getJson(); + } + result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, toscaDataToHandle); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private void updateDeepElements(GraphVertex toscaDataVertex, Map mergedDeepElementMap, List pathKeys) { + + if (toscaDataVertex != null && MapUtils.isNotEmpty(mergedDeepElementMap)) { + Map currMap = (Map) toscaDataVertex.getJson(); + if(!currMap.containsKey(pathKeys.get(0))){ + currMap.put(pathKeys.get(0), new MapDataDefinition<>()); + } + MapDataDefinition currDeepElement = currMap.get(pathKeys.get(0)); + + for (int i = 1; i < pathKeys.size(); ++i) { + if(currDeepElement.findByKey(pathKeys.get(i)) == null){ + currDeepElement.put(pathKeys.get(i), new MapDataDefinition<>()); + } + currDeepElement = (MapDataDefinition) currDeepElement.findByKey(pathKeys.get(i)); + } + if(currDeepElement != null){ + for (Map.Entry elementEntry : mergedDeepElementMap.entrySet()) { + currDeepElement.put(elementEntry.getKey(), elementEntry.getValue()); + } + } + } + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private Map getDeepElements(GraphVertex toscaDataVertex, List pathKeys) { + Map result = null; + Map currMap = (Map) toscaDataVertex.getJson(); + MapDataDefinition currDeepElement = (MapDataDefinition) currMap.get(pathKeys.get(0)); + for (int i = 1; i < pathKeys.size(); ++i) { + currDeepElement = (MapDataDefinition) currDeepElement.findByKey(pathKeys.get(i)); + } + if(currDeepElement != null){ + result = (Map) currDeepElement.getMapToscaDataDefinition(); + } + return result; + } + + @SuppressWarnings("unchecked") + private StorageOperationStatus addDeepElementsBlock(GraphVertex toscaDataVertex, T toscaDataBlock, String key) { + + StorageOperationStatus result = null; + Map currMap = (Map) toscaDataVertex.getJson(); + if (currMap.containsKey(key)) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add block of deep tosca data elements by label {}." + " The block element with the same key {} already exists. ", toscaDataVertex.getLabel(), key); + result = StorageOperationStatus.ENTITY_ALREADY_EXISTS; + } + if (result == null) { + currMap.put(key, toscaDataBlock); + } + return result; + } + + @SuppressWarnings("unchecked") + private StorageOperationStatus deleteDeepElementsBlock(GraphVertex toscaDataVertex, String key) { + + StorageOperationStatus result = null; + Map currMap = (Map) toscaDataVertex.getJson(); + if (!currMap.containsKey(key)) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete block of deep tosca data elements by label {}." + " The block element with the same key {} doesn't exist. ", toscaDataVertex.getLabel(), key); + result = StorageOperationStatus.NOT_FOUND; + } + if (result == null) { + currMap.remove(key); + } + return null; + } + + /** + * Removes tosca data vertex belonging to tosca element specified by uid according label + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @return + */ + public StorageOperationStatus removeToscaData(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { + + StorageOperationStatus statusRes = StorageOperationStatus.OK; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == StorageOperationStatus.OK) { + statusRes = removeToscaDataVertex(getToscaElementRes.left().value(), edgeLabel, vertexLabel); + } + return statusRes; + } + + /** + * Removes tosca data vertex belonging to tosca element according label + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @return + */ + public StorageOperationStatus removeToscaDataVertex(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { + StorageOperationStatus result = null; + GraphVertex toscaDataVertex = null; + Iterator edges = null; + int edgeCounter = 0; + Edge edge = null; + Edge edgeToDelete = null; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight()) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + toscaDataVertex = toscaDataVertexRes.left().value(); + edges = toscaDataVertex.getVertex().edges(Direction.IN); + if (edges == null || !edges.hasNext()) { + result = StorageOperationStatus.NOT_FOUND; + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, result); + } + } + if (result == null) { + if (edges!=null) { + while (edges.hasNext()) { + ++edgeCounter; + edge = edges.next(); + if (edge.outVertex().id().equals(toscaElement.getVertex().id())) { + edgeToDelete = edge; + break; + } + } + } + if (edgeToDelete == null) { + result = StorageOperationStatus.NOT_FOUND; + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, result); + } + } + if (result == null) { + if (edgeCounter > 1 && edgeToDelete!=null) { + edgeToDelete.remove(); + } else { + toscaDataVertex.getVertex().remove(); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + /** + * Deletes tosca data elements belonging to tosca element specified by uid according label + * + * @param toscaElementUid + * @param edgeLabel + * @param uniqueKeys + * @return + */ + public StorageOperationStatus deleteToscaDataElements(String toscaElementUid, EdgeLabelEnum edgeLabel, List uniqueKeys) { + + StorageOperationStatus statusRes = StorageOperationStatus.OK; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == StorageOperationStatus.OK) { + statusRes = deleteToscaDataElements(getToscaElementRes.left().value(), edgeLabel, uniqueKeys); + } + return statusRes; + } + + /** + * Deletes tosca data element belonging to tosca element specified by uid according label + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param uniqueKey + * @param mapKeyField + * @return + */ + public StorageOperationStatus deleteToscaDataElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = StorageOperationStatus.OK; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == StorageOperationStatus.OK) { + statusRes = deleteToscaDataElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, uniqueKey, mapKeyField); + } + return statusRes; + + } + + /** + * Deletes tosca data deep element belonging to tosca element specified by uid according label + * + * @param toscaElementUid + * @param edgeLabel + * @param vertexLabel + * @param uniqueKey + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus deleteToscaDataDeepElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, List pathKeys, JsonPresentationFields mapKeyField) { + + StorageOperationStatus statusRes = StorageOperationStatus.OK; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (statusRes == StorageOperationStatus.OK) { + statusRes = deleteToscaDataDeepElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, uniqueKey, pathKeys, mapKeyField); + } + return statusRes; + + } + + /** + * Deletes tosca data deep element belonging to tosca element according label + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param uniqueKey + * @param pathKeys + * @param mapKeyField + * @return + */ + public StorageOperationStatus deleteToscaDataDeepElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, List pathKeys, JsonPresentationFields mapKeyField) { + + List uniqueKeys = new ArrayList<>(); + uniqueKeys.add(uniqueKey); + return deleteToscaDataDeepElements(toscaElement, edgeLabel, vertexLabel, uniqueKeys, pathKeys, mapKeyField); + } + + public StorageOperationStatus deleteToscaDataDeepElements(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List uniqueKeys, List pathKeys, JsonPresentationFields mapKeyField) { + + StorageOperationStatus result = null; + GraphVertex toscaDataVertex; + Map existingToscaDataMap = null; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight()) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + toscaDataVertex = toscaDataVertexRes.left().value(); + existingToscaDataMap = getDeepElements(toscaDataVertexRes.left().value(), pathKeys); + result = deleteElementsFromDataVertex(toscaElement, edgeLabel, uniqueKeys, toscaDataVertex, existingToscaDataMap); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus deleteElementsFromDataVertex(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, List uniqueKeys, GraphVertex toscaDataVertex, Map existingToscaDataMap) { + StorageOperationStatus result; + for (String uniqueKey : uniqueKeys) { + result = removeKeyFromDataVertex(uniqueKey, existingToscaDataMap); + if (result != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca data element of the tosca element {} by label {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); + break; + } + } + result = updateToscaDataElement(toscaElement, edgeLabel, toscaDataVertex); + return result; + } + + /** + * Deletes tosca data element belonging to tosca element according label + * + * @param toscaElement + * @param edgeLabel + * @param vertexLabel + * @param uniqueKey + * @param mapKeyField + * @return + */ + public StorageOperationStatus deleteToscaDataElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, JsonPresentationFields mapKeyField) { + + List uniqueKeys = new ArrayList<>(); + uniqueKeys.add(uniqueKey); + return deleteToscaDataElements(toscaElement, edgeLabel, uniqueKeys); + } + + @SuppressWarnings("unchecked") +/** + * Deletes tosca data elements belonging to tosca element according label + * @param toscaElement + * @param edgeLabel + * @param uniqueKeys + * @return + */ + public StorageOperationStatus deleteToscaDataElements(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, List uniqueKeys) { + StorageOperationStatus result = null; + GraphVertex toscaDataVertex; + Map existingToscaDataMap; + Either toscaDataVertexRes = janusGraphDao + .getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); + if (toscaDataVertexRes.isRight()) { + JanusGraphOperationStatus status = toscaDataVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toscaDataVertexRes.right().value()); + } + if (result == null) { + toscaDataVertex = toscaDataVertexRes.left().value(); + existingToscaDataMap = (Map) toscaDataVertex.getJson(); + result = deleteElementsFromDataVertex(toscaElement, edgeLabel, uniqueKeys, toscaDataVertex, existingToscaDataMap); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + /** + * Adds the map data entry to the graph vertex of the specified type, related with the specified edge to the component specified by ID + * @param componentId The uniqueId of the component + * @param vertexTypeEnum The type of the vertex + * @param edgeLabelEnum The type of the edge + * @param mapDataEntry The map data entry + * @param + * @return The status of the operation result + */ + public StorageOperationStatus addElementToComponent(String componentId, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map.Entry mapDataEntry){ + if(MapUtils.isNotEmpty(mapDataEntry.getValue().getMapToscaDataDefinition())) + return addToscaDataDeepElementsBlockToToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, mapDataEntry.getValue(), mapDataEntry.getKey()); + return StorageOperationStatus.OK; + } + + private StorageOperationStatus updateToscaDataElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, GraphVertex toscaDataVertex) { + StorageOperationStatus result = StorageOperationStatus.OK; + Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); + if (updateOrCopyRes.isRight()) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateOrCopyRes.right().value()); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), result); + } + return result; + } + + private StorageOperationStatus removeKeyFromDataVertex(String uniqueKey, Map existingToscaDataMap) { + if (!existingToscaDataMap.containsKey(uniqueKey)) { + return StorageOperationStatus.NOT_FOUND; + } + existingToscaDataMap.remove(uniqueKey); + return StorageOperationStatus.OK; + } + + protected StorageOperationStatus handleToscaData(GraphVertex toscaElement, VertexTypeEnum vertexLabel, EdgeLabelEnum edgeLabel, GraphVertex toscaDataVertex, Map mergedToscaDataMap) { + + StorageOperationStatus result = StorageOperationStatus.OK; + if (toscaDataVertex == null) { + + Either createRes = associateElementToData(toscaElement, vertexLabel, edgeLabel, mergedToscaDataMap); + if (createRes.isRight()) { + StorageOperationStatus status = createRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to assosiate tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); + result = status; + } + } else { + toscaDataVertex.setJson(mergedToscaDataMap); + Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); + if (updateOrCopyRes.isRight()) { + JanusGraphOperationStatus status = updateOrCopyRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data {} to the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + return result; + } + + private Either, StorageOperationStatus> validateMergeToscaData(GraphVertex toscaElement, List toscaDataList, JsonPresentationFields mapKeyField, Map existingToscaDataMap, + boolean isUpdate) { + + Map mergedToscaDataMap = new HashMap<>(); + StorageOperationStatus status; + Either, StorageOperationStatus> result = Either.left(mergedToscaDataMap); + if (MapUtils.isNotEmpty(existingToscaDataMap)) { + mergedToscaDataMap.putAll(existingToscaDataMap); + } + for (T toscaDataElement : toscaDataList) { + status = handleToscaDataElement(toscaElement, mapKeyField, mergedToscaDataMap, toscaDataElement, isUpdate); + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + break; + } + } + return result; + } + + private StorageOperationStatus handleToscaDataElement(GraphVertex toscaElement, JsonPresentationFields mapKeyField, Map mergedToscaDataMap, T toscaDataElement, boolean isUpdate) { + + StorageOperationStatus status = StorageOperationStatus.OK; + String currKey = (String) toscaDataElement.getToscaPresentationValue(mapKeyField); + + if(StringUtils.isEmpty(currKey) && toscaDataElement instanceof ListDataDefinition) { + ToscaDataDefinition toscaDataDefinition = ((ListDataDefinition) toscaDataElement) + .getListToscaDataDefinition().get(0); + if(toscaDataDefinition != null) { + currKey = (String) toscaDataDefinition.getToscaPresentationValue(mapKeyField); + } + } + + if (StringUtils.isEmpty(currKey)) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data to tosca element {}. The key is empty. "); + status = StorageOperationStatus.BAD_REQUEST; + } else if (!isUpdate && mergedToscaDataMap.containsKey(currKey)) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data to tosca element {}. The element with the same key {} already exists. ", toscaElement.getUniqueId(), currKey); + status = StorageOperationStatus.BAD_REQUEST; + } + mergedToscaDataMap.put(currKey, toscaDataElement); + return status; + } + +// public StorageOperationStatus updateDataOnGraph(GraphVertex dataVertex) { +// Either updateVertex = janusGraphDao.updateVertex(dataVertex); +// if (updateVertex.isRight()) { +// return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateVertex.right().value()); +// } +// return StorageOperationStatus.OK; +// } + + protected GroupInstanceDataDefinition buildGroupInstanceDataDefinition(GroupDataDefinition group, ComponentInstanceDataDefinition componentInstance, Map instDeplArtifMap) { + + String componentInstanceName = componentInstance.getName(); + Long creationDate = System.currentTimeMillis(); + GroupInstanceDataDefinition groupInstance = new GroupInstanceDataDefinition(); + String groupUid = group.getUniqueId(); + + groupInstance.setGroupUid(groupUid); + groupInstance.setType(group.getType()); + groupInstance.setCustomizationUUID(generateCustomizationUUID()); + groupInstance.setCreationTime(creationDate); + groupInstance.setModificationTime(creationDate); + groupInstance.setName(buildGroupInstanceName(componentInstanceName, group.getName())); + groupInstance.setGroupName(group.getName()); + groupInstance.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(groupInstance.getName())); + groupInstance.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(componentInstance.getUniqueId(), groupUid, groupInstance.getNormalizedName())); + groupInstance.setArtifacts(group.getArtifacts()); + +// List fixedArtifactsUuid; +// List artifactsUuid = group.getArtifactsUuid(); +// if (instDeplArtifMap != null) { +// fixedArtifactsUuid = new ArrayList<>(); +// artifactsUuid.forEach(u -> { +// Optional findFirst = instDeplArtifMap.values().stream().filter(a -> u.equals(a.getUniqueId())).findFirst(); +// if (findFirst.isPresent()) { +// fixedArtifactsUuid.add(findFirst.get().getArtifactUUID()); +// } else { +// fixedArtifactsUuid.add(u); +// } +// }); +// } else { +// fixedArtifactsUuid = artifactsUuid; +// } + groupInstance.setArtifactsUuid(group.getArtifactsUuid()); + groupInstance.setProperties(group.getProperties()); + convertPropertiesToInstanceProperties(groupInstance.getProperties()); + groupInstance.setInvariantUUID(group.getInvariantUUID()); + groupInstance.setGroupUUID(group.getGroupUUID()); + groupInstance.setVersion(group.getVersion()); + + return groupInstance; + } + + + protected String buildGroupInstanceName(String instanceName, String groupName) { + return ValidationUtils.normalizeComponentInstanceName(instanceName) + ".." + groupName; + } + + protected String generateCustomizationUUID() { + return UUID.randomUUID().toString(); + } + + protected void convertPropertiesToInstanceProperties(List properties){ + properties.forEach(PropertyDataDefinition::convertPropertyDataToInstancePropertyData); + } + + private JanusGraphOperationStatus logAndReturn(JanusGraphOperationStatus janusGraphOperationStatus, String logMsg, Object ... logParams) { + log.debug(logMsg, logParams); + return janusGraphOperationStatus; + } + + protected GraphVertex throwStorageException(JanusGraphOperationStatus status) { + throw new StorageException(status); + } + + public void setHealingPipelineDao(HealingPipelineDao healingPipelineDao) { + this.healingPipelineDao = healingPipelineDao; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ByToscaNameDerivedNodeTypeResolver.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ByToscaNameDerivedNodeTypeResolver.java new file mode 100644 index 0000000000..a34dd7e920 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ByToscaNameDerivedNodeTypeResolver.java @@ -0,0 +1,56 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.DerivedNodeTypeResolver; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Component("derived-resource-resolver") +public class ByToscaNameDerivedNodeTypeResolver implements DerivedNodeTypeResolver { + + @Autowired + private JanusGraphDao janusGraphDao; + + @Override + public Either, JanusGraphOperationStatus> findDerivedResources(String parentResource) { + Map propertiesToMatch = new HashMap<>(); + propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + + propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, parentResource); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + return janusGraphDao + .getByCriteria(VertexTypeEnum.NODE_TYPE, propertiesToMatch, JsonParseFlagEnum.NoParse); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperation.java new file mode 100644 index 0000000000..3b544aaa39 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperation.java @@ -0,0 +1,156 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.collections.MapUtils; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.operations.StorageException; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@org.springframework.stereotype.Component("capabilities-operation") +public class CapabilitiesOperation extends BaseOperation { + private static final Logger LOGGER = LoggerFactory.getLogger(CapabilitiesOperation.class); + + public Either, StorageOperationStatus> addCapabilities(String componentId, + List capabilityDefinitions) { + return addOrUpdateCapabilities(componentId, capabilityDefinitions, false); + } + + public Either, StorageOperationStatus> updateCapabilities(String componentId, + List capabilityDefinitions) { + return addOrUpdateCapabilities(componentId, capabilityDefinitions, true); + } + + private Either, StorageOperationStatus> addOrUpdateCapabilities(String componentId, + List capabilityDefinitions, + boolean isUpdateAction) { + StorageOperationStatus statusRes = performUpdateToscaAction(isUpdateAction, + componentId, Collections.singletonList(convertToListCapabilityDataDefinition(capabilityDefinitions))); + if (!statusRes.equals(StorageOperationStatus.OK)) { + LOGGER.error("Failed to find the parent capability of capability type {}." + " status is {}", componentId, + statusRes); + return Either.right(statusRes); + } + return Either.left(capabilityDefinitions); + } + + public StorageOperationStatus deleteCapabilities(Component component, String capabilityIdToDelete) { + return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES, + Collections.singletonList(capabilityIdToDelete)); + } + + public StorageOperationStatus deleteCapabilityProperties(Component component, String capabilityPropIdToDelete) { + return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES_PROPERTIES, + Collections.singletonList(capabilityPropIdToDelete)); + } + + private static ListCapabilityDataDefinition convertToListCapabilityDataDefinition(List capabilities) { + List capabilityDefinitions = new ArrayList<>(capabilities); + return new ListCapabilityDataDefinition(capabilityDefinitions); + } + + private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, String componentId, + List toscaDataList) { + if (isUpdate) { + return updateToscaDataOfToscaElement(componentId, EdgeLabelEnum.CAPABILITIES, + VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE); + } else { + return addToscaDataToToscaElement(componentId, EdgeLabelEnum.CAPABILITIES, + VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE); + } + } + + private StorageOperationStatus createOrUpdateCapabilityProperties(String componentId, TopologyTemplate toscaElement, + Map propertiesMap) { + GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum + .NoParse) + .left().on(this::throwStorageException); + Map capabilitiesProperties = toscaElement.getCapabilitiesProperties(); + if(MapUtils.isNotEmpty(capabilitiesProperties)) { + + capabilitiesProperties.forEach((key, val) -> { + Map mapToscaDataDefinition = val.getMapToscaDataDefinition(); + mapToscaDataDefinition.forEach((key1, val1) -> { + + propertiesMap.forEach((propKey, propVal) -> { + Map propValMapToscaDataDefinition = propVal.getMapToscaDataDefinition(); + propValMapToscaDataDefinition.forEach((propKey1, propVal1) -> { + if(propKey1.equals(key1) && val1.getUniqueId().equals(propVal1.getUniqueId())) { + ToscaDataDefinition.mergeDataMaps(mapToscaDataDefinition, propValMapToscaDataDefinition); + } + }); + }); + }); + }); + + ToscaDataDefinition.mergeDataMaps(propertiesMap, capabilitiesProperties); + } + + return topologyTemplateOperation.updateFullToscaData(toscaElementV, + EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, propertiesMap); + } + + public StorageOperationStatus createOrUpdateCapabilityProperties(String componentId, + Map propertiesMap) { + StorageOperationStatus propertiesStatusRes = null; + if(MapUtils.isNotEmpty(propertiesMap)) { + propertiesStatusRes = createOrUpdateCapabilityProperties(componentId, getTopologyTemplate(componentId), + propertiesMap); + } + + return propertiesStatusRes; + } + + private TopologyTemplate getTopologyTemplate(String componentId) { + return (TopologyTemplate)topologyTemplateOperation + .getToscaElement(componentId, getFilterComponentWithCapProperties()) + .left() + .on(this::throwStorageException); + } + private ComponentParametersView getFilterComponentWithCapProperties() { + ComponentParametersView filter = new ComponentParametersView(); + filter.setIgnoreCapabiltyProperties(false); + return filter; + } + + private ToscaElement throwStorageException(StorageOperationStatus status) { + throw new StorageException(status); + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CategoryOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CategoryOperation.java new file mode 100644 index 0000000000..7603657b9a --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CategoryOperation.java @@ -0,0 +1,94 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@org.springframework.stereotype.Component("category-operation") +public class CategoryOperation extends BaseOperation{ + + private static final Logger log = Logger.getLogger(CategoryOperation.class.getName()); + + /** + * + * @param name + * @param type + * @return + */ + public Either getCategory(String name, VertexTypeEnum type) { + if (name != null) { + String categoryUid = UniqueIdBuilder.buildComponentCategoryUid(name, type); + Map props = new HashMap<>(); + props.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(name)); + Either, JanusGraphOperationStatus> either = janusGraphDao + .getByCriteria(type, props); + + if (either.isRight()) { + JanusGraphOperationStatus janusGraphOperationStatus = either.right().value(); + log.debug("Problem while geting category with id {}. reason - {}", categoryUid, janusGraphOperationStatus + .name()); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { + return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND); + } else { + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + } + return Either.left(either.left().value().get(0)); + } else { + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + } + /** + * + * @param categoryV + * @param name + * @return + */ + public Either getSubCategoryForCategory(GraphVertex categoryV, String name ) { + Either, JanusGraphOperationStatus> childrenVertecies = janusGraphDao + .getChildrenVertecies(categoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); + if ( childrenVertecies.isRight() ){ + log.debug("Failed to fetch children verticies for category {} error {}", categoryV.getUniqueId(), childrenVertecies.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childrenVertecies.right().value())); + } + for ( GraphVertex childV : childrenVertecies.left().value() ){ + if ( childV.getMetadataProperty(GraphPropertyEnum.NAME).equals(name) ){ + return Either.left(childV); + } + } + return Either.right(StorageOperationStatus.NOT_FOUND); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperation.java new file mode 100644 index 0000000000..6079c5ef15 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperation.java @@ -0,0 +1,297 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + + +import fj.data.Either; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.IdMapper; +import org.openecomp.sdc.be.model.operations.impl.OperationUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.*; + +import static java.util.Collections.emptyMap; + +/** + * Created by yavivi on 26/01/2018. + */ +@Component +public class ExternalReferencesOperation extends BaseOperation { + + @Autowired + private IdMapper idMapper; + + @Autowired + private OperationUtils operationUtils; + + + /** + * Constructor + */ + public ExternalReferencesOperation(JanusGraphDao janusGraphDao, NodeTypeOperation nto, TopologyTemplateOperation tto, IdMapper idMapper){ + this.janusGraphDao = janusGraphDao; + this.topologyTemplateOperation = tto; + this.nodeTypeOperation = nto; + this.idMapper = idMapper; + } + + public Either addExternalReferenceWithCommit(String serviceUuid, String componentInstanceName, String objectType, String reference) { + Either addResult = addExternalReference(serviceUuid, componentInstanceName, objectType, reference); + janusGraphDao.commit(); + return addResult; + } + + public Either deleteExternalReferenceWithCommit(String serviceUuid, String componentInstanceName, String objectType, String reference) { + Either result = deleteExternalReference(serviceUuid, componentInstanceName, objectType, reference); + janusGraphDao.commit(); + return result; + } + + public Either updateExternalReferenceWithCommit(String serviceVertexUuid, String componentInstanceName, String objectType, String oldRef, String newRef) { + Either updateResult = updateExternalReference(serviceVertexUuid, componentInstanceName, objectType, oldRef, newRef); + janusGraphDao.commit(); + return updateResult; + } + + public Either addExternalReference(String assetUuid, String componentInstanceName, String objectType, String reference) { + + //Get Container vertex + Either vertexById = janusGraphDao.getVertexById(assetUuid); + if (vertexById.isRight()){ + return Either.right(ActionStatus.RESOURCE_NOT_FOUND); + } + + GraphVertex serviceVertex = vertexById.left().value(); + + final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); + if (compInstanceUniqueId == null) { + return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); + } + + //Get the external references map vertex + final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + + //Check whether data vertex found + GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; + + //instanceId -> externalRefsMap + Map externalReferencesFullData; + if (externalRefsVertex == null) { + //External Refs vertex does not exist, create its map. + externalReferencesFullData = new HashMap<>(); + externalReferencesFullData.put(compInstanceUniqueId, new MapComponentInstanceExternalRefs()); + } else { + externalReferencesFullData = (Map) externalRefsVertex.getJson(); + externalReferencesFullData.computeIfAbsent(compInstanceUniqueId, k -> new MapComponentInstanceExternalRefs()); + } + + boolean isAdded = addExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, reference); + updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); + + return isAdded ? Either.left(reference) : Either.right(ActionStatus.EXT_REF_ALREADY_EXIST); + } + + public Either deleteExternalReference(String assetUuid, String componentInstanceName, String objectType, String reference){ + //Get Service vertex + Either vertexById = janusGraphDao.getVertexById(assetUuid); + if (vertexById.isRight()){ + return Either.right(ActionStatus.RESOURCE_NOT_FOUND); + } + GraphVertex serviceVertex = vertexById.left().value(); + + final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); + if (compInstanceUniqueId == null) { + return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); + } + + //Get the external references map vertex + final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + + //Check whether data vertex found + GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; + boolean refDeleted = false; + if (externalRefsVertex != null) { + Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); + if (externalReferencesFullData != null) { + refDeleted = deleteExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, reference); + updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); + } + } + + if (refDeleted) { + return Either.left(reference); + } else { + return Either.right(ActionStatus.EXT_REF_NOT_FOUND); + } + } + + public Either updateExternalReference(String assetUuid, String componentInstanceName, String objectType, String oldRef, String newRef) { + //Get Service vertex + Either vertexById = janusGraphDao.getVertexById(assetUuid); + if (vertexById.isRight()){ + return Either.right(ActionStatus.RESOURCE_NOT_FOUND); + } + + GraphVertex serviceVertex = vertexById.left().value(); + + //Map instance_name -> uuid + final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); + if (compInstanceUniqueId == null) { + return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); + } + + //Get the external references map vertex + final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + + //Check whether data vertex found + GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; + boolean refReplaced = false; + if (externalRefsVertex != null) { + Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); + if (externalReferencesFullData != null) { + refReplaced = updateExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, oldRef, newRef); + updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); + } + } + if (refReplaced) { + return Either.left(newRef); + } else { + return Either.right(ActionStatus.EXT_REF_NOT_FOUND); + } + } + + public Either>, ActionStatus> getExternalReferences(String assetUuid, String objectType) { + //Get Service vertex + Either vertexById = janusGraphDao.getVertexById(assetUuid); + if (vertexById.isRight()){ + return Either.right(ActionStatus.RESOURCE_NOT_FOUND); + } + + GraphVertex serviceVertex = vertexById.left().value(); + + Map> result = new HashMap(); + + //Get the external references map vertex + final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + //Check whether data vertex found + GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; + if (externalRefsVertex != null) { + Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); + if (externalReferencesFullData != null) { + externalReferencesFullData.entrySet().forEach( + s -> { + List externalRefsByObjectType = externalReferencesFullData.get(s.getKey()).getExternalRefsByObjectType(objectType); + List refList = externalRefsByObjectType == null ? new ArrayList<>() : externalRefsByObjectType; + String key = idMapper.mapUniqueIdToComponentNameTo(s.getKey(), serviceVertex); + result.put(key, refList); + } + ); + return Either.left(result); + } + } + //No external References Node found on this asset + return Either.left(new HashMap<>()); + } + + public void addAllExternalReferences(String containerUniqueId, + String compInstanceUniqueId, + Map> instanceExternalReferences) { + + GraphVertex serviceVertex = janusGraphDao.getVertexById(containerUniqueId) + .left() + .on(operationUtils::onJanusGraphOperationFailure); + Either dataVertex = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + Map externalReferencesFullData; + if (dataVertex.isLeft()) { + externalReferencesFullData = (Map) dataVertex.left().value().getJson(); + } else { + externalReferencesFullData = new HashMap<>(); + } + externalReferencesFullData.put(compInstanceUniqueId, new MapComponentInstanceExternalRefs(instanceExternalReferences)); + updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); + } + + public Map> getAllExternalReferences(String containerUniqueId, + String compInstanceUniqueId) { + GraphVertex serviceVertex = janusGraphDao.getVertexById(containerUniqueId) + .left() + .on(operationUtils::onJanusGraphOperationFailure); + + Either dataVertex = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + if (dataVertex.isRight()) { + return new HashMap<>(); + } + GraphVertex externalRefsVertex = dataVertex.left().value(); + Map externalReferencesFullData = externalRefsVertex == null ? null : (Map) externalRefsVertex.getJson(); + if (externalReferencesFullData != null) { + return externalReferencesFullData + .getOrDefault(compInstanceUniqueId, new MapComponentInstanceExternalRefs()) + .getComponentInstanceExternalRefs(); + } + return emptyMap(); + } + + public Either, ActionStatus> getExternalReferences(String assetUuid, String componentInstanceName, String objectType) { + //Get Service vertex + Either vertexById = janusGraphDao.getVertexById(assetUuid); + if (vertexById.isRight()){ + return Either.right(ActionStatus.RESOURCE_NOT_FOUND); + } + + GraphVertex serviceVertex = vertexById.left().value(); + final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); + if (compInstanceUniqueId == null) { + return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); + } + + //Get the external references map vertex + final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); + + //Check whether data vertex found + GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; + if (externalRefsVertex != null) { + Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); + if (externalReferencesFullData != null) { + return Either.left(getExternalReferencesByObjectId(externalReferencesFullData, compInstanceUniqueId, objectType)); + } + } + + //No external References Node found on this asset + return Either.left(new LinkedList()); + } + + public IdMapper getIdMapper() { + return idMapper; + } + + public void setIdMapper(IdMapper idMapper) { + this.idMapper = idMapper; + } + + private List getExternalReferencesByObjectId(Map externalReferencesFullData, String componentInstanceId, String objectType) { + MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); + List externalRefsByObjectType = externalRefsMap.getExternalRefsByObjectType(objectType); + return externalRefsByObjectType != null ? externalRefsByObjectType : new LinkedList<>(); + } + + private boolean updateExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String oldRef, String newRef) { + MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); + return externalRefsMap.replaceExternalRef(objectType, oldRef, newRef); + } + + private boolean deleteExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String reference) { + MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); + return externalRefsMap.deleteExternalRef(objectType, reference); + } + + private boolean addExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String reference) { + MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); + return externalRefsMap.addExternalRef(objectType, reference); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ForwardingPathOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ForwardingPathOperation.java new file mode 100644 index 0000000000..f7372a6e28 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ForwardingPathOperation.java @@ -0,0 +1,118 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.log.wrappers.Logger; + +import java.util.*; + +@org.springframework.stereotype.Component("forwarding-paths-operations") +public class ForwardingPathOperation extends BaseOperation { + private static final Logger log = Logger.getLogger(ForwardingPathOperation.class.getName()); + + + public Either, StorageOperationStatus> deleteForwardingPath(Service service, Set forwardingPathsToDelete) { + Either, StorageOperationStatus> result = null; + Either getComponentVertex; + StorageOperationStatus status = null; + + if (result == null) { + getComponentVertex = janusGraphDao + .getVertexById(service.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + } + if (result == null) { + + status = deleteToscaDataElements(service.getUniqueId(), EdgeLabelEnum.FORWARDING_PATH,new ArrayList<>(forwardingPathsToDelete)); + + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + + if (result == null) { + result = Either.left(forwardingPathsToDelete); + } + return result; + } + + public Either addForwardingPath(String serviceId, ForwardingPathDataDefinition currentPath) { + return addOrUpdateForwardingPath(false, serviceId, currentPath); + } + + public Either updateForwardingPath(String serviceId, ForwardingPathDataDefinition currentPath) { + return addOrUpdateForwardingPath(true, serviceId, currentPath); + } + + private Either addOrUpdateForwardingPath(boolean isUpdateAction, String serviceId, ForwardingPathDataDefinition currentPath) { + + StorageOperationStatus statusRes; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(serviceId, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(log, CommonUtility.LogLevelEnum.DEBUG, "Failed to get tosca element {} upon adding the properties. Status is {}. ", serviceId, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + return Either.right(statusRes); + } + GraphVertex serviceVertex = getToscaElementRes.left().value(); + if (!isUpdateAction){ + currentPath.setUniqueId(UUID.randomUUID().toString()); + } + statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, Arrays.asList(currentPath), JsonPresentationFields.FORWARDING_PATH); + { + if (!statusRes.equals(StorageOperationStatus.OK)) { + log.error("Failed to find the parent capability of capability type {}. status is {}", serviceId, statusRes); + return Either.right(statusRes); + } + return Either.left(currentPath); + } + + } + + + private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, GraphVertex graphVertex, List toscaDataList, JsonPresentationFields mapKeyField) { + if (isUpdate) { + return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.FORWARDING_PATH, VertexTypeEnum.FORWARDING_PATH, toscaDataList, JsonPresentationFields.UNIQUE_ID); + } else { + return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.FORWARDING_PATH, VertexTypeEnum.FORWARDING_PATH, toscaDataList, JsonPresentationFields.UNIQUE_ID); + } + } + +} + + + diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperation.java new file mode 100644 index 0000000000..03bab3b31e --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperation.java @@ -0,0 +1,397 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.collections.MapUtils; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +import org.openecomp.sdc.be.model.operations.StorageException; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("groups-operation") +public class GroupsOperation extends BaseOperation { + + private static final Logger log = Logger.getLogger(GroupsOperation.class.getName()); + + public StorageOperationStatus deleteCalculatedCapabilitiesWithProperties(String componentId, List groupDefinitions) { + Optional error = groupDefinitions.stream().map(g->removeCalculatedCapabilityFromComponent(componentId, g.getUniqueId())).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + if(!error.isPresent()){ + Map extractCapabilityPropertiesFromGroups = ModelConverter.extractCapabilityPropertiesFromGroups(groupDefinitions, false); + error = extractCapabilityPropertiesFromGroups.keySet().stream().map(k->removeCalculatedCapabilityPropertiesFromComponent(componentId, k)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + } + if(error.isPresent()){ + return error.get(); + } + return StorageOperationStatus.OK; + } + + /** + * Adds the map of the calculated capabilities and the map of the calculated capabilities properties the the component on the graph + * @param componentId + * @param calculatedCapabilities + * @param calculatedCapabilitiesProperties + * @return status of the result the operation + */ + public StorageOperationStatus addCalculatedCapabilitiesWithProperties(String componentId, Map calculatedCapabilities, Map calculatedCapabilitiesProperties) { + + Optional error = calculatedCapabilities.entrySet().stream().map(e-> addElementToComponent(componentId, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + if(!error.isPresent()){ + error = calculatedCapabilitiesProperties.entrySet().stream().map(e->addCalculatedCapabilityPropertiesToComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + } + if(error.isPresent()){ + return error.get(); + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus updateCalculatedCapabilitiesWithProperties(String componentId, Map calculatedCapabilities, Map calculatedCapabilitiesProperties) { + + Optional error = calculatedCapabilities.entrySet().stream().map(e->updateCalculatedCapabilityOfComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + if(!error.isPresent()){ + error = calculatedCapabilitiesProperties.entrySet().stream().map(e->updateCalculatedCapabilityPropertiesOnComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); + } + if(error.isPresent()){ + return error.get(); + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus updateCalculatedCapabilityOfComponent(String componentId, Entry capabilities){ + if(MapUtils.isNotEmpty(capabilities.getValue().getMapToscaDataDefinition())) + return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAPABILITIES, capabilities.getValue(), capabilities.getKey()); + return StorageOperationStatus.OK; + } + + private StorageOperationStatus addCalculatedCapabilityPropertiesToComponent(String componentId, Entry properties){ + if(MapUtils.isNotEmpty(properties.getValue().getMapToscaDataDefinition())) + return addToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, properties.getValue(), properties.getKey()); + return StorageOperationStatus.OK; + } + + private StorageOperationStatus updateCalculatedCapabilityPropertiesOnComponent(String componentId, Entry properties){ + if(MapUtils.isNotEmpty(properties.getValue().getMapToscaDataDefinition())) + return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, properties.getValue(), properties.getKey()); + return StorageOperationStatus.OK; + } + + private StorageOperationStatus removeCalculatedCapabilityFromComponent(String componentId, String groupId){ + return deleteToscaDataDeepElementsBlockOfToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, groupId); + } + + private StorageOperationStatus removeCalculatedCapabilityPropertiesFromComponent(String componentId, String groupId){ + return deleteToscaDataDeepElementsBlockOfToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, groupId); + } + + + public Either, StorageOperationStatus> createGroups(Component component, Map groups) { + + Either, StorageOperationStatus> result = null; + Either getComponentVertex = null; + StorageOperationStatus status = null; + + getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + status = topologyTemplateOperation.associateGroupsToComponent(getComponentVertex.left().value(), groups); + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + if (result == null) { + result = Either.left(ModelConverter.convertToGroupDefinitions(groups)); + } + return result; + } + + public Either, StorageOperationStatus> addGroups(Component component, List groups) { + Either, StorageOperationStatus> result = null; + Either getComponentVertex; + StorageOperationStatus status; + + getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + status = addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groups, JsonPresentationFields.NAME); + + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + + if (result == null) { + Map mapGroup = groups.stream().collect(Collectors.toMap(GroupDataDefinition::getName, x->x)); + result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); + } + return result; + } + + public Either, StorageOperationStatus> deleteGroups(Component component, List groups) { + Either, StorageOperationStatus> result = null; + Either getComponentVertex = null; + StorageOperationStatus status = null; + + getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + List groupName = groups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()); + status = deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.GROUPS, groupName); + + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + + if (result == null) { + Map mapGroup = groups.stream().collect(Collectors.toMap( GroupDataDefinition::getName, x->x)); + result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); + } + return result; + } + + public Either, StorageOperationStatus> updateGroups(Component component, List groups, boolean promoteVersion) { + Either, StorageOperationStatus> result = null; + Either getComponentVertex = null; + StorageOperationStatus status = null; + + getComponentVertex = janusGraphDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + groups.forEach(gr -> { + updateVersion(promoteVersion, gr); + String groupUUID = UniqueIdBuilder.generateUUID(); + gr.setGroupUUID(groupUUID); + }); + + status = updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groups, JsonPresentationFields.NAME); + + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + + if (result == null) { + Map mapGroup = groups.stream().collect(Collectors.toMap( GroupDataDefinition::getName, x->x)); + result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); + } + return result; + } + + private void updateVersion(boolean promoteVersion, T group) { + if(promoteVersion) { + String version = group.getVersion(); + String newVersion = increaseMajorVersion(version); + group.setVersion(newVersion); + } + } + + public void updateGroupOnComponent(String componentId, GroupDefinition groupDefinition) { + GraphVertex componentVertex = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata) + .left() + .on(this::onJanusGraphError); + + StorageOperationStatus updateToscaResult = updateToscaDataOfToscaElement(componentVertex, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groupDefinition, + JsonPresentationFields.NAME); + + if (StorageOperationStatus.OK != updateToscaResult) { + throw new StorageException(updateToscaResult, groupDefinition.getUniqueId()); + } + + updateLastUpdateDate(componentVertex); + } + + private void updateLastUpdateDate(GraphVertex componentVertex) { + componentVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + janusGraphDao.updateVertex(componentVertex) + .left() + .on(this::onJanusGraphError); + } + + GraphVertex onJanusGraphError(JanusGraphOperationStatus janusGraphOperationStatus) { + throw new StorageException( + DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphOperationStatus)); + } + + public Either, StorageOperationStatus> updateGroupPropertiesOnComponent(String componentId, GroupDefinition group, List newGroupProperties) { + + Either, StorageOperationStatus> result = null; + Either getComponentVertex = null; + GraphVertex componentVertex = null; + + getComponentVertex = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); + if (getComponentVertex.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component {}. Status is {} ", componentId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + componentVertex = getComponentVertex.left().value(); + //update + List properties = group.getProperties(); + newGroupProperties.forEach(np -> { + Optional currentProp = properties.stream().filter(p -> p.getName().equals(np.getName())).findAny(); + if (currentProp.isPresent()) { + currentProp.get().setValue(np.getValue()); + } + }); + + StorageOperationStatus updateDataRes = updateToscaDataOfToscaElement(componentVertex, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, group, JsonPresentationFields.NAME); + if (updateDataRes != StorageOperationStatus.OK) { + log.debug("Failed to update properties for group {} error {}", group.getName(), updateDataRes); + result = Either.right(updateDataRes); + } + } + if (result == null) { + componentVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + Either updateRes = janusGraphDao.updateVertex(componentVertex); + if (updateRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the component {}. Status is {} ", componentId, updateRes.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateRes.right().value())); + } + } + if (result == null) { + result = Either.left(newGroupProperties); + } + return result; + } + + /** + * The version of the group is an integer. In order to support BC, we might get a version in a float format. + * + * @param version + * @return + */ + private String increaseMajorVersion(String version) { + + String[] versionParts = version.split(ToscaElementLifecycleOperation.VERSION_DELIMITER_REGEXP); + Integer majorVersion = Integer.parseInt(versionParts[0]); + + majorVersion++; + + return String.valueOf(majorVersion); + + } + + public Either, StorageOperationStatus> updateGroupInstances(Component component, String instanceId, List updatedGroupInstances) { + + Either, StorageOperationStatus> result = null; + StorageOperationStatus status = null; + + Either getComponentVertex = janusGraphDao + .getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + if (result == null) { + List pathKeys = new ArrayList<>(); + pathKeys.add(instanceId); + status = updateToscaDataDeepElementsOfToscaElement(component.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, updatedGroupInstances, pathKeys, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } + if (result == null) { + result = Either.left(updatedGroupInstances); + } + return result; + } + + public Either updateGroup(Component component, GroupDefinition currentGroup) { + StorageOperationStatus status = updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroup, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update group {} of component {}. The status is}. ", currentGroup.getName(), component.getName(), status); + return Either.right(status); + } + return Either.left(currentGroup); + } + + public StorageOperationStatus deleteGroup(Component component, String currentGroupName) { + StorageOperationStatus status = deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroupName, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete group {} of component {}. The status is}. ", currentGroupName, component.getName(), status); + } + return status; + } + + public Either addGroup(Component component, GroupDefinition currentGroup) { + StorageOperationStatus status = addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroup, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update group {} of component {}. The status is}. ", currentGroup.getName(), component.getName(), status); + return Either.right(status); + } + return Either.left(currentGroup); + } + + public Either updateGroupInstancePropertyValuesOnGraph(String componentId, String instanceId, GroupInstance oldGroupInstance, List newProperties) { + + Either getComponentVertex = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); + if (getComponentVertex.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component {}. Status is {} ", componentId); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + + List propertiesOld = oldGroupInstance.getProperties(); + newProperties.forEach(np -> { + Optional prop = propertiesOld.stream().filter(p -> p.getName().equals(np.getName())).findFirst(); + if (prop.isPresent()) { + prop.get().setValue(np.getValue()); + } + }); + GroupInstanceDataDefinition groupInstanceDataDefinition = new GroupInstanceDataDefinition(oldGroupInstance); + List pathKeys = new ArrayList<>(); + pathKeys.add(instanceId); + StorageOperationStatus updateDataRes = updateToscaDataDeepElementOfToscaElement(componentId, EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, groupInstanceDataDefinition, pathKeys, JsonPresentationFields.NAME); + if (updateDataRes != StorageOperationStatus.OK) { + log.debug("Failed to update properties for group instance {} error {}", oldGroupInstance.getName(), updateDataRes); + return Either.right(updateDataRes); + } + return Either.left(oldGroupInstance); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InstancesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InstancesOperation.java new file mode 100644 index 0000000000..3378e03318 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InstancesOperation.java @@ -0,0 +1,25 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +public class InstancesOperation extends BaseOperation { + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperation.java new file mode 100644 index 0000000000..0b6f48f051 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperation.java @@ -0,0 +1,98 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import org.apache.commons.collections.MapUtils; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.InterfaceDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; + +@org.springframework.stereotype.Component("interfaces-operation") +public class InterfaceOperation extends BaseOperation { + + public Either, StorageOperationStatus> addInterfaces(String componentId, + List interfaceDefinitions) { + return addOrUpdateInterfaces(false, componentId, interfaceDefinitions); + } + + private Either, StorageOperationStatus> addOrUpdateInterfaces(boolean isUpdateAction, + String componentId, List interfaceDefinitions) { + + List interfaceDataDefinitions = + interfaceDefinitions.stream().map(InterfaceDataDefinition::new).collect(Collectors.toList()); + StorageOperationStatus statusRes = + performUpdateToscaAction(isUpdateAction, componentId, interfaceDataDefinitions, EdgeLabelEnum.INTERFACE, + VertexTypeEnum.INTERFACE); + if (!statusRes.equals(StorageOperationStatus.OK)) { + return Either.right(statusRes); + } + return Either.left(interfaceDefinitions); + } + + private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, String componentId, + List toscaDataList, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { + if (isUpdate) { + return updateToscaDataOfToscaElement(componentId, edgeLabel, vertexLabel, toscaDataList, + JsonPresentationFields.UNIQUE_ID); + } else { + return addToscaDataToToscaElement(componentId, edgeLabel, vertexLabel, toscaDataList, + JsonPresentationFields.UNIQUE_ID); + } + } + + public Either, StorageOperationStatus> updateInterfaces(String componentId, + List interfaceDefinitions) { + return addOrUpdateInterfaces(true, componentId, interfaceDefinitions); + } + + public Either deleteInterface(String componentId, String interfacesToDelete) { + + StorageOperationStatus statusRes = deleteToscaDataElements(componentId, EdgeLabelEnum.INTERFACE, + Collections.singletonList(interfacesToDelete)); + if (!statusRes.equals(StorageOperationStatus.OK)) { + return Either.right(statusRes); + } + + Either, JanusGraphOperationStatus> componentEither = + getDataFromGraph(componentId, EdgeLabelEnum.INTERFACE); + if (componentEither.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(componentEither.right().value())); + } + + Map interfaceDataDefinitionMap = componentEither.left().value(); + if (MapUtils.isEmpty(interfaceDataDefinitionMap)) { + statusRes = removeToscaData(componentId, EdgeLabelEnum.INTERFACE, VertexTypeEnum.INTERFACE); + if (!statusRes.equals(StorageOperationStatus.OK)) { + return Either.right(statusRes); + } + } + + return Either.left(interfacesToDelete); + } + +} \ No newline at end of file diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java new file mode 100644 index 0000000000..13ad534bbb --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java @@ -0,0 +1,176 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import fj.data.Either; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.log.wrappers.Logger; + +@org.springframework.stereotype.Component("service-filter-operations") +public class NodeFilterOperation extends BaseOperation { + + private static Logger logger = Logger.getLogger(NodeFilterOperation.class); + + public Either, StorageOperationStatus> deleteNodeFilters(Service service, + Set componentInstanceIds) { + Either getComponentVertex; + Either getNodeFilterVertex; + StorageOperationStatus status; + + getComponentVertex = janusGraphDao.getVertexById(service.getUniqueId(), JsonParseFlagEnum.NoParse); + if (getComponentVertex.isRight()) { + return Either.right( + DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getComponentVertex.right().value())); + } + + getNodeFilterVertex = + janusGraphDao.getChildVertex(getComponentVertex.left().value(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, + JsonParseFlagEnum.NoParse); + if (getNodeFilterVertex.isLeft()) { + status = deleteToscaDataElements(service.getUniqueId(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, + new ArrayList<>(componentInstanceIds)); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + + return Either.left(componentInstanceIds); + } + + + public Either deleteNodeFilter(Service service, String componentInstanceId) { + final Either, StorageOperationStatus> listStorageOperationStatusEither = + deleteNodeFilters(service, ImmutableSet.of(componentInstanceId)); + if (listStorageOperationStatusEither.isRight()) { + return Either.right(listStorageOperationStatusEither.right().value()); + } + return Either.left(componentInstanceId); + } + + + public Either createNodeFilter(String serviceId, + String componentInstanceId) { + CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition(); + return addOrUpdateNodeFilter(false, serviceId, componentInstanceId, nodeFilterDataDefinition); + } + + public Either deleteConstraint(String serviceId, + String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, int propertyIndex) { + ListDataDefinition properties = + nodeFilterDataDefinition.getProperties(); + properties.getListToscaDataDefinition().remove(propertyIndex); + nodeFilterDataDefinition.setProperties(properties); + return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); + } + + public Either addNewProperty(String serviceId, + String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, + RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) { + ListDataDefinition properties = + nodeFilterDataDefinition.getProperties(); + if (properties == null) { + properties = new ListDataDefinition<>(); + nodeFilterDataDefinition.setProperties(properties); + } + properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition); + nodeFilterDataDefinition.setProperties(properties); + return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); + } + + public Either updateProperties(String serviceId, + String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, + List requirementNodeFilterPropertyDataDefinition) { + ListDataDefinition properties = + nodeFilterDataDefinition.getProperties(); + properties.getListToscaDataDefinition().clear(); + properties.getListToscaDataDefinition().addAll(requirementNodeFilterPropertyDataDefinition); + nodeFilterDataDefinition.setProperties(properties); + return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); + } + + public Either updateNodeFilter(String serviceId, + String componentInstanceId, CINodeFilterDataDefinition ciNodeFilterDataDefinition) { + return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, ciNodeFilterDataDefinition); + } + + private Either addOrUpdateNodeFilter(boolean isUpdateAction, + String serviceId, String componentInstanceId, CINodeFilterDataDefinition ciNodeFilterDataDefinition) { + + StorageOperationStatus statusRes; + Either getToscaElementRes; + + getToscaElementRes = janusGraphDao.getVertexById(serviceId, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + JanusGraphOperationStatus status = getToscaElementRes.right().value(); + CommonUtility.addRecordToLog(logger, CommonUtility.LogLevelEnum.DEBUG, + "Failed to get tosca element {} upon adding the properties. Status is {}. ", serviceId, status); + statusRes = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + return Either.right(statusRes); + } + GraphVertex serviceVertex = getToscaElementRes.left().value(); + ciNodeFilterDataDefinition.setID(componentInstanceId); + statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, ImmutableList.of(ciNodeFilterDataDefinition)); + if (!statusRes.equals(StorageOperationStatus.OK)) { + janusGraphDao.rollback(); + logger.error( + " Failed to perform tosca update for node filter in service {} , component instance {}. status is {}", + serviceId, componentInstanceId, statusRes); + return Either.right(statusRes); + } + janusGraphDao.commit(); + return Either.left(ciNodeFilterDataDefinition); + + } + + + private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, GraphVertex graphVertex, + List toscaDataList) { + if (isUpdate) { + return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, + VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID); + } else { + return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, + VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID); + } + } + +} + + + diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java new file mode 100644 index 0000000000..2861337aec --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java @@ -0,0 +1,2417 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.config.BeEcompErrorManager; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.ComponentInstanceInput; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.GroupInstance; +import org.openecomp.sdc.be.model.InputDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.RelationshipImpl; +import org.openecomp.sdc.be.model.RelationshipInfo; +import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; +import org.openecomp.sdc.be.model.RequirementDefinition; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; +import org.openecomp.sdc.common.api.ArtifactTypeEnum; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; + +import java.io.IOException; +import java.util.*; +import java.util.Map.Entry; +import java.util.function.BiConsumer; +import java.util.function.BiPredicate; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("node-template-operation") +public class NodeTemplateOperation extends BaseOperation { + private static final String FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR = "Failed to fetch container vertex {} error {}"; + private static final String FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE = "Failed to update topology template {} with new component instance {}. "; + private static final String ARTIFACT_PLACEHOLDER_TYPE = "type"; + private static final String ARTIFACT_PLACEHOLDER_DISPLAY_NAME = "displayName"; + private static final Object ARTIFACT_PLACEHOLDER_DESCRIPTION = "description"; + public static final String HEAT_ENV_NAME = "heatEnv"; + public static final String HEAT_VF_ENV_NAME = "VfHeatEnv"; + public static final String HEAT_ENV_SUFFIX = "env"; + private static Integer defaultHeatTimeout; + public static final Integer NON_HEAT_TIMEOUT = 0; + + private static final Logger log = Logger.getLogger(NodeTemplateOperation.class.getName()); + + public NodeTemplateOperation() { + defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getDefaultHeatArtifactTimeoutMinutes(); + if ((defaultHeatTimeout == null) || (defaultHeatTimeout < 1)) { + defaultHeatTimeout = 60; + } + } + + public static Integer getDefaultHeatTimeout() { + return defaultHeatTimeout; + } + + public Either, StorageOperationStatus> addComponentInstanceToTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, String instanceNumberSuffix, ComponentInstance componentInstance, + boolean allowDeleted, User user) { + + Either, StorageOperationStatus> result = null; + Either addComponentInstanceRes = null; + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to create component instance {} in component {}", componentInstance, container.getUniqueId()); + ComponentInstanceDataDefinition componentInstanceData = null; + Either newInstanceNameRes = null; + + Either metadataVertex = janusGraphDao + .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseJson); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + if (result == null) { + + newInstanceNameRes = buildValidateInstanceName(container, originToscaElement, componentInstance, instanceNumberSuffix); + if (newInstanceNameRes.isRight()) { + result = Either.right(newInstanceNameRes.right().value()); + } + } + if (result == null) { + componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), newInstanceNameRes.left().value(), true, originToscaElement); + + addComponentInstanceRes = addComponentInstanceToTopologyTemplate(container, originToscaElement, componentInstanceData, metadataVertex.left().value(), allowDeleted, user); + + if (addComponentInstanceRes.isRight()) { + StorageOperationStatus status = addComponentInstanceRes.right().value(); + if (status == StorageOperationStatus.NOT_FOUND) { + status = StorageOperationStatus.INVALID_ID; + } + result = Either.right(status); + } + if (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy) { + TopologyTemplate updatedContainer = addComponentInstanceRes.left().value(); + result = addServerCapAndReqToProxyServerInstance(updatedContainer, componentInstance, componentInstanceData); + if(result.isRight()) { + return result; + } + + result = addServiceInstancePropertiesToProxyServiceInstance(updatedContainer, componentInstance); + if(result.isRight()) { + return result; + } + + result = addServiceInstanceInputsToProxyServiceInstance(updatedContainer, componentInstance); + if(result.isRight()) { + return result; + } + + result = addServiceInstanceInterfacesToProxyServiceInstance(updatedContainer, componentInstance); + if(result.isRight()) { + return result; + } + + } + } + if (result == null) { + result = Either.left(new ImmutablePair<>(addComponentInstanceRes.left().value(), componentInstanceData.getUniqueId())); + } + return result; + } + + private Either, StorageOperationStatus> addServerCapAndReqToProxyServerInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance, + + ComponentInstanceDataDefinition componentInstanceData) { + + Either, StorageOperationStatus> result; + + Map calcCap = updatedContainer.getCalculatedCapabilities(); + Map calcReg = updatedContainer.getCalculatedRequirements(); + Map calcCapProp = updatedContainer.getCalculatedCapabilitiesProperties(); + + Map> additionalCap = componentInstance.getCapabilities(); + Map> additionalReq = componentInstance.getRequirements(); + + MapListCapabilityDataDefinition allCalculatedCap = calcCap == null || !calcCap.containsKey(componentInstanceData.getUniqueId()) ? new MapListCapabilityDataDefinition() : calcCap.get(componentInstanceData.getUniqueId()); + /******** capability ****************************/ + StorageOperationStatus status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, componentInstanceData.getUniqueId()); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); + return Either.right(status); + } + + if (additionalCap != null && !additionalCap.isEmpty()) { + + Map serverCap = additionalCap.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, en -> new ListCapabilityDataDefinition(en.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())))); + + serverCap.entrySet().forEach(entryPerType -> + entryPerType.getValue().getListToscaDataDefinition().forEach(cap -> { + cap.addToPath(componentInstance.getUniqueId()); + allCalculatedCap.add(entryPerType.getKey(), cap); + })); + + + addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap, componentInstance.getUniqueId()); + + /******** capability property ****************************/ + status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, componentInstanceData.getUniqueId()); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty properties for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); + return Either.right(status); + } + + MapCapabilityProperty allCalculatedCapProp = calcCapProp == null || !calcCapProp.containsKey(componentInstanceData.getUniqueId()) ? new MapCapabilityProperty() : calcCapProp.get(componentInstanceData.getUniqueId()); + + additionalCap.forEach(new BiConsumer>() { + @Override + public void accept(String s, List caps) { + + if (caps != null && !caps.isEmpty()) { + + MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + + for (CapabilityDefinition cap : caps) { + List capPrps = cap.getProperties(); + if (capPrps != null) { + + for (ComponentInstanceProperty cip : capPrps) { + dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip)); + } + + StringBuilder sb = new StringBuilder(componentInstance.getUniqueId()); + sb.append(ModelConverter.CAP_PROP_DELIM); + + sb.append(cap.getOwnerId()); + + sb.append(ModelConverter.CAP_PROP_DELIM).append(s).append(ModelConverter.CAP_PROP_DELIM).append(cap.getName()); + allCalculatedCapProp.put(sb.toString(), dataToCreate); + } + } + + } + + } + }); + + addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, allCalculatedCapProp, componentInstance.getUniqueId()); + } + + /******** Requirements property ****************************/ + if (additionalReq != null && !additionalReq.isEmpty()) { + + MapListRequirementDataDefinition allCalculatedReq = calcReg == null || !calcReg.containsKey(componentInstanceData.getUniqueId()) ? new MapListRequirementDataDefinition() : calcReg.get(componentInstanceData.getUniqueId()); + status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, componentInstanceData.getUniqueId()); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated Requirements for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); + return Either.right(status); + } + + Map serverReq = additionalReq.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, en -> new ListRequirementDataDefinition(en.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())))); + + serverReq.entrySet().forEach(entryPerType -> + entryPerType.getValue().getListToscaDataDefinition().forEach(cap -> { + cap.addToPath(componentInstance.getUniqueId()); + allCalculatedReq.add(entryPerType.getKey(), cap); + })); + + + addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq, componentInstance.getUniqueId()); + + } + + Either updatedComponentInstanceRes = topologyTemplateOperation.getToscaElement(updatedContainer.getUniqueId()); + if (updatedComponentInstanceRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with new component instance {}. ", updatedContainer.getName(), componentInstance.getName()); + result = Either.right(updatedComponentInstanceRes.right().value()); + } + result = Either.left(new ImmutablePair<>((TopologyTemplate) updatedComponentInstanceRes.left().value(), componentInstanceData.getUniqueId())); + return result; + } + + private Either buildValidateInstanceName(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance, String instanceNumberSuffix) { + + Either result = null; + String instanceName = componentInstance.getName(); + if (StringUtils.isEmpty(instanceName) || instanceName.equalsIgnoreCase(originToscaElement.getName()) || componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy) { + instanceName = buildComponentInstanceName(instanceNumberSuffix, instanceName); + } else if (!isUniqueInstanceName(container, componentInstance.getName())) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create component instance with name {} on component container {}. The instance with the same name already exists. ", componentInstance.getName(), container.getName()); + result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS); + } + if (result == null) { + result = Either.left(instanceName); + } + return result; + } + + private Either, StorageOperationStatus> addServiceInstancePropertiesToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { + + List propertiesList = componentInstance.getProperties(); + + if (propertiesList != null && !propertiesList.isEmpty()) { + Map propertiesMap = propertiesList.stream().map(PropertyDataDefinition::new) + .collect(Collectors.toMap( + PropertyDataDefinition::getName, i -> i)); + MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(propertiesMap); + Map instPropertiesMap = new HashMap<>(); + instPropertiesMap.put(componentInstance.getUniqueId(), instProperties); + updatedContainer.setInstProperties(instPropertiesMap); + Either getToscaElementRes = janusGraphDao + .getVertexById(updatedContainer.getUniqueId(), JsonParseFlagEnum.NoParse); + if(getToscaElementRes.isLeft()){ + deleteToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), EdgeLabelEnum.INST_PROPERTIES, + VertexTypeEnum.INST_PROPERTIES, componentInstance.getUniqueId()); + } + StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), + EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, instProperties, + componentInstance.getUniqueId()); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + + + } + return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); + } + + private Either, StorageOperationStatus> addServiceInstanceInputsToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { + + List inputsList = componentInstance.getInputs(); + + if (CollectionUtils.isNotEmpty(inputsList)) { + Map inputsMap = inputsList.stream().map( + PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, i -> i)); + MapPropertiesDataDefinition instInputs = new MapPropertiesDataDefinition(inputsMap); + Map instInputsMap = new HashMap<>(); + instInputsMap.put(componentInstance.getUniqueId(), instInputs); + updatedContainer.setInstInputs(instInputsMap); + + StorageOperationStatus status = + addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), + EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, instInputs, + componentInstance.getUniqueId()); + if(status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + + return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); + } + + private Either, StorageOperationStatus> addServiceInstanceInterfacesToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { + Map interfaces = componentInstance.getInterfaces(); + + if(MapUtils.isNotEmpty(interfaces)){ + Map interfacesMap = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> (InterfaceDataDefinition) e.getValue())); + MapInterfaceDataDefinition instInterfaces = new MapInterfaceDataDefinition(interfacesMap); + + Map instInterfacesMap = new HashMap<>(); + instInterfacesMap.put(componentInstance.getUniqueId(), instInterfaces); + updatedContainer.setComponentInstInterfaces(instInterfacesMap); + + StorageOperationStatus status = + addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), + EdgeLabelEnum.INST_INTERFACES, VertexTypeEnum.INST_INTERFACES, instInterfaces, + componentInstance.getUniqueId()); + + if(status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + + return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); + } + + public Either addComponentInstanceToTopologyTemplate( + TopologyTemplate container, ToscaElement originToscaElement, + ComponentInstanceDataDefinition componentInstance, GraphVertex metadataVertex, boolean allowDeleted, + User user) { + + Either result = null; + Either updateContainerComponentRes = null; + String containerComponentId = container.getUniqueId(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to create component instance {} in component {}", componentInstance, containerComponentId); + String instOriginComponentId = componentInstance.getComponentUid(); + Either updateElement = null; + + Boolean isDeleted = (Boolean) originToscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED); + + if (!allowDeleted && (isDeleted != null) && isDeleted) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance", instOriginComponentId); + result = Either.right(StorageOperationStatus.INVALID_ID); + } + Boolean isArchived = originToscaElement.isArchived(); + if ( isArchived != null && isArchived ){ + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create instance {}. Origin {} component is archived . ", componentInstance.getName(), originToscaElement.getName()); + result = Either.right(StorageOperationStatus.COMPONENT_IS_ARCHIVED); + } + + if (result == null) { + container.addComponentInstance(componentInstance); + metadataVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + topologyTemplateOperation.fillToscaElementVertexData(metadataVertex, container, JsonParseFlagEnum.ParseAll); + updateElement = janusGraphDao.updateVertex(metadataVertex); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value())); + } + } + if (result == null) { + Either addToscaDataRes = addComponentInstanceToscaDataToContainerComponent(originToscaElement, componentInstance, updateElement.left().value(), user); + if (addToscaDataRes.isRight()) { + result = Either.right(addToscaDataRes.right().value()); + } + } + if (result == null) { + StorageOperationStatus createInstanceEdge = createInstanceEdge(metadataVertex, componentInstance); + result = createInstanceEdge == StorageOperationStatus.OK ? null : Either.right(createInstanceEdge); + } + + if (result == null) { + updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); + if (updateContainerComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with new component instance {}. ", container.getName(), componentInstance.getName()); + result = Either.right(updateContainerComponentRes.right().value()); + } + } + if (result == null) { + result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value()); + } + return result; + } + + public Either, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance) { + + Either, StorageOperationStatus> result = null; + Either updateContainerComponentRes = null; + + String containerComponentId = container.getUniqueId(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstance, containerComponentId); + ComponentInstanceDataDefinition componentInstanceData = null; + + Either metadataVertex = janusGraphDao + .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), componentInstance.getName(), false, originToscaElement); + container.addComponentInstance(componentInstanceData); + metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll); + Either updateElement = janusGraphDao + .updateVertex(metadataVertex.left().value()); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value())); + } + } + if (result == null) { + updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); + if (updateContainerComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", container.getName(), componentInstance.getName()); + result = Either.right(updateContainerComponentRes.right().value()); + } + } + if (result == null) { + result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceData.getUniqueId())); + } + return result; + } + + public Either updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container, ComponentParametersView filter) { + + Either result = null; + Either updateContainerComponentRes = null; + + String containerComponentId = container.getUniqueId(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata of container component {}", containerComponentId); + + Either metadataVertex = janusGraphDao + .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll); + Either updateElement = janusGraphDao + .updateVertex(metadataVertex.left().value()); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {}. ", container.getName()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value())); + } + } + if (result == null) { + updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId, filter); + if (updateContainerComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {}. ", container.getName()); + result = Either.right(updateContainerComponentRes.right().value()); + } + } + if (result == null) { + result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value()); + } + return result; + } + + public Either, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(TopologyTemplate container, String componentInstanceId) { + + Either, StorageOperationStatus> result = null; + Either updateContainerComponentRes = null; + + String containerComponentId = container.getUniqueId(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstanceId, containerComponentId); + + Either metadataVertex = janusGraphDao + .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + GraphVertex containerV = null; + ComponentInstanceDataDefinition removedComponentInstance = null; + if (result == null) { + removedComponentInstance = container.getComponentInstances().remove(componentInstanceId); + containerV = metadataVertex.left().value(); + StorageOperationStatus status = removeRelationsOfInstance(container, componentInstanceId, containerV); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete relation for component instance {} in container. error {}", componentInstanceId, container.getUniqueId(), status); + result = Either.right(status); + } + + containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + topologyTemplateOperation.fillToscaElementVertexData(containerV, container, JsonParseFlagEnum.ParseAll); + Either updateElement = janusGraphDao.updateVertex(containerV); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstanceId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value())); + } + } + if (result == null) { + StorageOperationStatus status = deleteComponentInstanceToscaDataFromContainerComponent(containerV, componentInstanceId); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete data for instance {} in container {}. error {] ", componentInstanceId, container.getUniqueId(), status); + return Either.right(status); + } + ComponentInstance componentInstance = new ComponentInstance(removedComponentInstance); + StorageOperationStatus createInstanceEdge = removeInstanceEdge(containerV, componentInstance); + result = createInstanceEdge == StorageOperationStatus.OK ? null : Either.right(createInstanceEdge); + } + if (result == null) { + updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); + if (updateContainerComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} after deleting the component instance {}. ", container.getName(), componentInstanceId); + result = Either.right(updateContainerComponentRes.right().value()); + } + } + if (result == null) { + result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceId)); + } + return result; + } + + private StorageOperationStatus removeRelationsOfInstance(TopologyTemplate container, String ciToRemove, GraphVertex containerV) { + CompositionDataDefinition composition = container.getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()); + if (composition != null) { + Map relations = composition.getRelations(); + if (MapUtils.isNotEmpty(relations)) { + Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (capResult.isRight()) { + return capResult.right().value(); + + } + Map calculatedCapabilty = capResult.left().value().getRight(); + + Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (capFullResult.isRight()) { + return capFullResult.right().value(); + + } + Map fullFilledCapabilty = capFullResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (reqResult.isRight()) { + return reqResult.right().value(); + } + Map calculatedRequirement = reqResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (reqResult.isRight()) { + return reqResult.right().value(); + } + Map fullfilledRequirement = reqFullResult.left().value().getRight(); + + Iterator> iterator = relations.entrySet().iterator(); + while (iterator.hasNext()) { + Entry relation = iterator.next(); + RelationshipInstDataDefinition relationToDelete = relation.getValue(); + if (relationToDelete.getFromId().equals(ciToRemove) || relationToDelete.getToId().equals(ciToRemove)) { + iterator.remove(); + if (relationToDelete.getFromId().equals(ciToRemove)) { + updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, ciToRemove, relationToDelete, null); + updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, relationToDelete.getToId(), relationToDelete, null); + } + if (relationToDelete.getToId().equals(ciToRemove)) { + updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, relationToDelete.getFromId(), relationToDelete, null); + updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, ciToRemove, relationToDelete, null); + } + } + } + return updateAllAndCalculatedCapReqOnGraph(container.getUniqueId(), containerV, capResult, capFullResult, reqResult, reqFullResult); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus deleteComponentInstanceToscaDataFromContainerComponent(GraphVertex containerV, String componentInstanceId) { + StorageOperationStatus status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled capabilities for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove attributes for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance inputs for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance deployment artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INSTANCE_ARTIFACTS, VertexTypeEnum.INSTANCE_ARTIFACTS, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance external refs for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_INTERFACES, + VertexTypeEnum.INST_INTERFACES, componentInstanceId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, + "Failed to remove service instance interfaces for instance {} in container {}. " + + "error {] ", componentInstanceId, containerV.getUniqueId(), status); + return status; + } + return StorageOperationStatus.OK; + } + + protected Either addComponentInstanceToscaDataToContainerComponent(ToscaElement originToscaElement, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex, User user) { + + Either result; + StorageOperationStatus status; + if (originToscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) { + status = addComponentInstanceToscaDataToNodeTypeContainer((NodeType) originToscaElement, componentInstance, updatedContainerVertex); + } else { + status = addComponentInstanceToscaDataToTopologyTemplateContainer((TopologyTemplate) originToscaElement, componentInstance, updatedContainerVertex); + } + if (status == StorageOperationStatus.OK) { + result = Either.left(updatedContainerVertex); + } else { + result = Either.right(status); + } + return result; + } + + private StorageOperationStatus addComponentInstanceToscaDataToTopologyTemplateContainer(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { + + StorageOperationStatus status; + + status = addCalculatedCapReqFromTopologyTemplate(originTopologyTemplate, componentInstance, updatedContainerVertex); + + if (status != StorageOperationStatus.OK) { + + return status; + } + + MapPropertiesDataDefinition instInputs = new MapPropertiesDataDefinition(originTopologyTemplate.getInputs()); + MapPropertiesDataDefinition instInputsAsProperties = turnInputsIntoProperties(instInputs); + + status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, instInputsAsProperties, componentInstance.getUniqueId()); + if (status != StorageOperationStatus.OK) { + return status; + } + + return status; + } + + private MapPropertiesDataDefinition turnInputsIntoProperties(MapPropertiesDataDefinition instInput){ + if (instInput.getMapToscaDataDefinition() != null) { + for (PropertyDataDefinition currProp : instInput.getMapToscaDataDefinition().values()){ + String temp = currProp.getValue(); + currProp.setValue(currProp.getDefaultValue()); + currProp.setDefaultValue(temp); + } + } + return instInput; + } + + private MapListCapabilityDataDefinition prepareCalculatedCapabiltyForTopologyTemplate( + Map capabilities, + ComponentInstanceDataDefinition componentInstance, + MapListCapabilityDataDefinition calculatedCap) { + MapListCapabilityDataDefinition allCalculatedCap = + new MapListCapabilityDataDefinition(calculatedCap); + populateCapability(capabilities, componentInstance, allCalculatedCap); + return allCalculatedCap; + } + + private void populateCapability(Map capabilities, + ComponentInstanceDataDefinition componentInstance, + MapListCapabilityDataDefinition allCalculatedCap) { + capabilities.forEach((key, value) -> { + List listCapabilities = value.getListToscaDataDefinition() + .stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()); + listCapabilities.forEach(cap -> { + cap.setSource(componentInstance.getComponentUid()); + cap.addToPath(componentInstance.getUniqueId()); + cap.setOwnerId(componentInstance.getUniqueId()); + cap.setOwnerName(componentInstance.getName()); + cap.setLeftOccurrences(cap.getMaxOccurrences()); + allCalculatedCap.add(key, cap); + }); + }); + } + + private MapListRequirementDataDefinition prepareCalculatedRequirementForTopologyTemplate( + Map requirements, + ComponentInstanceDataDefinition componentInstance, + MapListRequirementDataDefinition calculatedReqs) { + MapListRequirementDataDefinition allCalculatedReq = + new MapListRequirementDataDefinition(calculatedReqs); + + populateRequirement(requirements, componentInstance, allCalculatedReq); + return allCalculatedReq; + } + private void populateRequirement(Map requirements, + ComponentInstanceDataDefinition componentInstance, + MapListRequirementDataDefinition allCalculatedReq) { + requirements.forEach((key, value) -> { + List listRequirements = value.getListToscaDataDefinition() + .stream().map(RequirementDataDefinition::new).collect(Collectors.toList()); + listRequirements.forEach(req -> { + req.setSource(componentInstance.getComponentUid()); + req.addToPath(componentInstance.getUniqueId()); + req.setOwnerId(componentInstance.getUniqueId()); + req.setOwnerName(componentInstance.getName()); + req.setLeftOccurrences(req.getMaxOccurrences()); + allCalculatedReq.add(key, req); + }); + }); + } + + + + private StorageOperationStatus addCalculatedCapReqFromTopologyTemplate(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { + Map calculatedCapabilities = originTopologyTemplate.getCalculatedCapabilities(); + + MapListCapabilityDataDefinition allCalculatedCap = new MapListCapabilityDataDefinition(); + if (calculatedCapabilities != null) { + calculatedCapabilities.forEach((key1, value1) -> { + Map mapByType = value1.getMapToscaDataDefinition(); + mapByType.forEach((key, value) -> value.getListToscaDataDefinition().forEach(cap -> { + cap.addToPath(componentInstance.getUniqueId()); + allCalculatedCap.add(key, cap); + })); + }); + } + MapListCapabilityDataDefinition allCaps; + Map capabilities = originTopologyTemplate.getCapabilities(); + if (MapUtils.isNotEmpty(capabilities)) { + allCaps = prepareCalculatedCapabiltyForTopologyTemplate(capabilities, componentInstance, + allCalculatedCap); + } else { + allCaps = new MapListCapabilityDataDefinition(allCalculatedCap); + } + if(!allCaps.isEmpty()) { + StorageOperationStatus calculatedCapabilitiesResult = + addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, + EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, + allCaps, componentInstance.getUniqueId()); + if (calculatedCapabilitiesResult != StorageOperationStatus.OK) { + return calculatedCapabilitiesResult; + } + MapListCapabilityDataDefinition fullCalculatedCap = new MapListCapabilityDataDefinition(); + calculatedCapabilitiesResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, + EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, + fullCalculatedCap, componentInstance.getUniqueId()); + if (calculatedCapabilitiesResult != StorageOperationStatus.OK) { + return calculatedCapabilitiesResult; + } + } + Map calculatedRequirements = + originTopologyTemplate.getCalculatedRequirements(); + MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition(); + if (calculatedRequirements != null) { + calculatedRequirements.forEach((key, value) -> { + Map mapByType = + value.getMapToscaDataDefinition(); + mapByType.forEach((key1, value1) -> value1.getListToscaDataDefinition().forEach(req -> { + req.addToPath(componentInstance.getUniqueId()); + allCalculatedReq.add(key1, req); + })); + }); + + } + + MapListRequirementDataDefinition allReqs; + Map requirements = originTopologyTemplate.getRequirements(); + if (MapUtils.isNotEmpty(requirements)) { + allReqs = prepareCalculatedRequirementForTopologyTemplate(requirements, + componentInstance, allCalculatedReq); + } else + allReqs = new MapListRequirementDataDefinition(allCalculatedReq); + + if(!allReqs.isEmpty()) { + StorageOperationStatus calculatedRequirementResult = + addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, + EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, + allReqs, componentInstance.getUniqueId()); + if (calculatedRequirementResult != StorageOperationStatus.OK) { + return calculatedRequirementResult; + } + MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition(); + calculatedRequirementResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, + EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, + fullCalculatedReq, + componentInstance.getUniqueId()); + if (calculatedRequirementResult != StorageOperationStatus.OK) { + return calculatedRequirementResult; + } + } + Map calculatedCapabilitiesProperties = originTopologyTemplate.getCalculatedCapabilitiesProperties(); + Map updateKeyMap = new HashMap<>(); + + if (calculatedCapabilitiesProperties != null && !calculatedCapabilitiesProperties.isEmpty()) { + for (MapCapabilityProperty map : calculatedCapabilitiesProperties.values()) { + for (Entry entry : map.getMapToscaDataDefinition().entrySet()) { + String newKey = (componentInstance.getUniqueId() + ModelConverter.CAP_PROP_DELIM + entry.getKey()); + updateKeyMap.put(newKey, entry.getValue()); + } + } + } + Map capabilitiesProperties = + originTopologyTemplate.getCapabilitiesProperties(); + Map updateKeyMapCapabilitiesProperties; + if (MapUtils.isNotEmpty(capabilitiesProperties)) { + updateKeyMapCapabilitiesProperties = capabilitiesProperties.entrySet().stream() + .collect(Collectors.toMap(e -> createCapPropertyKey(e.getKey(), + componentInstance.getUniqueId()), Entry::getValue)); + } + else { + updateKeyMapCapabilitiesProperties = new HashMap<>(); + } + updateKeyMap.putAll(updateKeyMapCapabilitiesProperties); + MapCapabilityProperty mapCapabilityProperty = new MapCapabilityProperty(updateKeyMap); + + if(MapUtils.isNotEmpty(capabilitiesProperties) || MapUtils.isNotEmpty(calculatedCapabilitiesProperties )) { + StorageOperationStatus calculatedResult = + addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, + EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, + VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabilityProperty, + componentInstance.getUniqueId()); + if (calculatedResult != StorageOperationStatus.OK) { + return calculatedResult; + } + } + return StorageOperationStatus.OK; + } + private StorageOperationStatus addComponentInstanceToscaDataToNodeTypeContainer(NodeType originNodeType, + ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { + + StorageOperationStatus status; + + if(MapUtils.isNotEmpty(originNodeType.getProperties())){ + MapPropertiesDataDefinition instProperties = + new MapPropertiesDataDefinition(originNodeType.getProperties()); + status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_PROPERTIES, + VertexTypeEnum.INST_PROPERTIES, instProperties, componentInstance.getUniqueId()); + if (status != StorageOperationStatus.OK) { + return status; + } + } + + if(MapUtils.isNotEmpty(originNodeType.getAttributes())){ + MapPropertiesDataDefinition instAttributes = + new MapPropertiesDataDefinition(originNodeType.getAttributes()); + status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_ATTRIBUTES, + VertexTypeEnum.INST_ATTRIBUTES, instAttributes, componentInstance.getUniqueId()); + if (status != StorageOperationStatus.OK) { + return status; + } + } + + return addCalculatedCapReqFromNodeType(originNodeType, componentInstance, updatedContainerVertex); + } + + public MapArtifactDataDefinition prepareInstDeploymentArtifactPerInstance(Map deploymentArtifacts, String componentInstanceId, User user, String envType) { + if (deploymentArtifacts != null && envType.equals(HEAT_VF_ENV_NAME)) { + Map instDeploymentArtifacts = new HashMap<>(); + + deploymentArtifacts.entrySet().forEach(e -> { + ArtifactDataDefinition artifact = e.getValue(); + String type = artifact.getArtifactType(); + if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) { + ArtifactDataDefinition artifactEnv = createArtifactPlaceHolderInfo(artifact, componentInstanceId, user, envType); + instDeploymentArtifacts.put(artifactEnv.getArtifactLabel(), artifactEnv); + } + }); + + deploymentArtifacts.putAll(instDeploymentArtifacts); + + return new MapArtifactDataDefinition(deploymentArtifacts); + + } + return null; + } + + @SuppressWarnings({ "unchecked" }) + private ArtifactDataDefinition createArtifactPlaceHolderInfo(ArtifactDataDefinition artifactHeat, String componentId, User user, String heatEnvType) { + Map deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getDeploymentResourceInstanceArtifacts(); + if (deploymentResourceArtifacts == null) { + log.debug("no deployment artifacts are configured for generated artifacts"); + return null; + } + Map placeHolderData = (Map) deploymentResourceArtifacts.get(heatEnvType); + if (placeHolderData == null) { + log.debug("no env type {} are configured for generated artifacts", heatEnvType); + return null; + } + + String envLabel = (artifactHeat.getArtifactLabel() + HEAT_ENV_SUFFIX).toLowerCase(); + + ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition(); + + String artifactName = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DISPLAY_NAME); + String artifactType = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_TYPE); + String artifactDescription = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DESCRIPTION); + + artifactInfo.setArtifactDisplayName(artifactName); + artifactInfo.setArtifactLabel(envLabel); + artifactInfo.setArtifactType(artifactType); + artifactInfo.setDescription(artifactDescription); + artifactInfo.setArtifactGroupType(artifactHeat.getArtifactGroupType()); + setDefaultArtifactTimeout(artifactHeat.getArtifactGroupType(), artifactInfo); + artifactInfo.setGeneratedFromId(artifactHeat.getUniqueId()); + // clone heat parameters in case of heat env only not VF heat env + if (heatEnvType.equals(HEAT_ENV_NAME)) { + artifactInfo.setHeatParameters(artifactHeat.getHeatParameters()); + } + setArtifactPlaceholderCommonFields(componentId, user, artifactInfo); + + return artifactInfo; + } + + public void setDefaultArtifactTimeout(ArtifactGroupTypeEnum groupType, ArtifactDataDefinition artifactInfo) { + if (groupType.equals(ArtifactGroupTypeEnum.DEPLOYMENT)) { + artifactInfo.setTimeout(defaultHeatTimeout); + } else { + artifactInfo.setTimeout(NON_HEAT_TIMEOUT); + } + } + + private void setArtifactPlaceholderCommonFields(String resourceId, User user, ArtifactDataDefinition artifactInfo) { + String uniqueId = null; + + if (resourceId != null) { + uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId.toLowerCase(), artifactInfo.getArtifactLabel().toLowerCase()); + artifactInfo.setUniqueId(uniqueId); + } + artifactInfo.setUserIdCreator(user.getUserId()); + String fullName = user.getFullName(); + artifactInfo.setUpdaterFullName(fullName); + + long time = System.currentTimeMillis(); + + artifactInfo.setCreatorFullName(fullName); + artifactInfo.setCreationDate(time); + + artifactInfo.setLastUpdateDate(time); + artifactInfo.setUserIdLastUpdater(user.getUserId()); + + artifactInfo.setMandatory(true); + } + + /** + * + * @param originNodeType + * @param componentInstance + * @param updatedContainerVertex + * @return + */ + private StorageOperationStatus addCalculatedCapReqFromNodeType(NodeType originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { + + Map capabilities = originNodeType.getCapabilities(); + MapListCapabilityDataDefinition allCalculatedCap = prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance); + StorageOperationStatus calculatedResult; + if (allCalculatedCap != null) { + calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap, componentInstance.getUniqueId()); + + if (calculatedResult != StorageOperationStatus.OK) { + return calculatedResult; + } + } + Map capabiltiesProperties = originNodeType.getCapabilitiesProperties(); + if (capabiltiesProperties != null) { + Map updateKeyMap = capabiltiesProperties.entrySet().stream().collect(Collectors.toMap(e -> createCapPropertyKey(e.getKey(), componentInstance.getUniqueId()), Entry::getValue)); + MapCapabilityProperty mapCapabilityProperty = new MapCapabilityProperty(updateKeyMap); + calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabilityProperty, componentInstance.getUniqueId()); + if (calculatedResult != StorageOperationStatus.OK) { + return calculatedResult; + } + } + + MapListCapabilityDataDefinition fullCalculatedCap = new MapListCapabilityDataDefinition(); + calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, fullCalculatedCap, componentInstance.getUniqueId()); + + if (calculatedResult != StorageOperationStatus.OK) { + return calculatedResult; + } + + Map requirements = originNodeType.getRequirements(); + + MapListRequirementDataDefinition allCalculatedReq = prepareCalculatedRequirementForNodeType(requirements, componentInstance); + + StorageOperationStatus status; + if (allCalculatedReq != null) { + status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq, componentInstance.getUniqueId()); + if (status != StorageOperationStatus.OK) { + return status; + } + } + MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition(); + addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, fullCalculatedReq, componentInstance.getUniqueId()); + return StorageOperationStatus.OK; + + } + + public static String createCapPropertyKey(String key, String instanceId) { + StringBuilder sb = new StringBuilder(instanceId); + sb.append(ModelConverter.CAP_PROP_DELIM).append(instanceId).append(ModelConverter.CAP_PROP_DELIM).append(key); + return sb.toString(); + } + + /** + * Prepares a map of capabilities lists Produces a deep copy of the received map of capabilities Sets values to the specific fields according to received component instance + * + * @param capabilities + * @param componentInstance + * @return + */ + public MapListCapabilityDataDefinition prepareCalculatedCapabiltyForNodeType(Map capabilities, ComponentInstanceDataDefinition componentInstance) { + if (capabilities != null) { + MapListCapabilityDataDefinition allCalculatedCap = new MapListCapabilityDataDefinition(); + + populateCapability(capabilities, componentInstance, allCalculatedCap); + return allCalculatedCap; + } + return null; + } + + /** + * Prepares a map of requirements lists Produces a deep copy of the received map of requirements Sets values to the specific fields according to received component instance + * + * @param requirements + * @param componentInstance + * @return + */ + public MapListRequirementDataDefinition prepareCalculatedRequirementForNodeType(Map requirements, ComponentInstanceDataDefinition componentInstance) { + if (requirements != null) { + MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition(); + + populateRequirement(requirements, componentInstance, allCalculatedReq); + return allCalculatedReq; + } + return null; + } + + public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstanceDataDefinition componentInstance, List groups, Map> groupInstancesArtifacts) { + + StorageOperationStatus result = null; + Map groupInstanceToCreate = new HashMap<>(); + if (groupInstancesArtifacts != null && CollectionUtils.isNotEmpty(groups)) { + for (Map.Entry> groupArtifacts : groupInstancesArtifacts.entrySet()) { + Optional groupOptional = groups.stream().filter(g -> g.getUniqueId().equals(groupArtifacts.getKey())).findFirst(); + if (groupOptional.isPresent()) { + GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition((GroupDataDefinition) groupOptional.get(), (ComponentInstanceDataDefinition) componentInstance, null); + groupInstance.setGroupInstanceArtifacts(groupArtifacts.getValue().stream().map(ArtifactDataDefinition::getUniqueId).collect(Collectors.toList())); + groupInstance.setGroupInstanceArtifactsUuid(groupArtifacts.getValue().stream().map(ArtifactDataDefinition::getArtifactUUID).collect(Collectors.toList())); + groupInstanceToCreate.put(groupInstance.getName(), groupInstance); + } + } + } + if (MapUtils.isNotEmpty(groupInstanceToCreate)) { + result = addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, new MapDataDefinition<>(groupInstanceToCreate), componentInstance.getUniqueId()); + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private ComponentInstanceDataDefinition buildComponentInstanceDataDefinition(ComponentInstance resourceInstance, String containerComponentId, String instanceNewName, boolean generateUid, ToscaElement originToscaElement) { + String ciOriginComponentUid = resourceInstance.getComponentUid(); + + if (!ValidationUtils.validateStringNotEmpty(resourceInstance.getCustomizationUUID())) { + resourceInstance.setCustomizationUUID(generateCustomizationUUID()); + } + ComponentInstanceDataDefinition dataDefinition = new ComponentInstanceDataDefinition(resourceInstance); + + Long creationDate = resourceInstance.getCreationTime(); + Long modificationTime; + if (creationDate == null) { + creationDate = System.currentTimeMillis(); + modificationTime = creationDate; + } else { + modificationTime = System.currentTimeMillis(); + } + dataDefinition.setComponentUid(ciOriginComponentUid); + dataDefinition.setCreationTime(creationDate); + dataDefinition.setModificationTime(modificationTime); + if (StringUtils.isNotEmpty(instanceNewName)) { + dataDefinition.setName(instanceNewName); + resourceInstance.setName(instanceNewName); + } + if (StringUtils.isNotEmpty(dataDefinition.getName())) + dataDefinition.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(dataDefinition.getName())); + dataDefinition.setIcon(resourceInstance.getIcon()); + if (generateUid) { + dataDefinition.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(containerComponentId, ciOriginComponentUid, dataDefinition.getNormalizedName())); + resourceInstance.setUniqueId(dataDefinition.getUniqueId()); + } + if (StringUtils.isEmpty(dataDefinition.getComponentVersion()) && originToscaElement != null) + dataDefinition.setComponentVersion((String) originToscaElement.getMetadataValue(JsonPresentationFields.VERSION)); + if (StringUtils.isEmpty(dataDefinition.getComponentName()) && originToscaElement != null) + dataDefinition.setComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.NAME)); + if (originToscaElement != null && dataDefinition.getToscaComponentName() == null) + dataDefinition.setToscaComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); + if (dataDefinition.getOriginType() == null && originToscaElement != null) { + ResourceTypeEnum resourceType = originToscaElement.getResourceType(); + OriginTypeEnum originType = OriginTypeEnum.findByValue(resourceType.name()); + dataDefinition.setOriginType(originType); + } + if (dataDefinition.getOriginType() == OriginTypeEnum.ServiceProxy) + dataDefinition.setIsProxy(true); + + return dataDefinition; + } + + private Boolean isUniqueInstanceName(TopologyTemplate container, String instanceName) { + Boolean isUniqueName = true; + try { + isUniqueName = !container.getComponentInstances().values().stream().filter(ci -> ci.getName() != null && ci.getName().equals(instanceName)).findAny().isPresent(); + + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during fetching component instance with name {} from component container {}. {} ", instanceName, container.getName(), e.getMessage()); + } + return isUniqueName; + } + + private String buildComponentInstanceName(String instanceSuffixNumber, String instanceName) { + return instanceName + " " + (instanceSuffixNumber == null ? 0 : instanceSuffixNumber); + } + + public Either associateResourceInstances(String componentId, RequirementCapabilityRelDef relation) { + List relations = new ArrayList<>(); + relations.add(relation); + Either, StorageOperationStatus> associateResourceInstances = associateResourceInstances(componentId, relations); + if (associateResourceInstances.isRight()) { + return Either.right(associateResourceInstances.right().value()); + } + return Either.left(associateResourceInstances.left().value().get(0)); + } + + @SuppressWarnings({ "unchecked" }) + public Either, StorageOperationStatus> associateResourceInstances(String componentId, List relations) { + + Either containerVEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (containerVEither.isRight()) { + JanusGraphOperationStatus error = containerVEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + GraphVertex containerV = containerVEither.left().value(); + Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (capResult.isRight()) { + return Either.right(capResult.right().value()); + + } + Map calculatedCapabilty = capResult.left().value().getRight(); + + Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (capResult.isRight()) { + return Either.right(capResult.right().value()); + + } + Map fullFilledCapabilty = capFullResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (reqResult.isRight()) { + return Either.right(reqResult.right().value()); + } + Map calculatedRequirement = reqResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (reqResult.isRight()) { + return Either.right(reqResult.right().value()); + } + Map fullfilledRequirement = reqFullResult.left().value().getRight(); + + Map jsonComposition = (Map) containerV.getJson(); + CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + + StorageOperationStatus status; + List relationsList = new ArrayList<>(); + for (RequirementCapabilityRelDef relation : relations) { + List relationshipsResult = new ArrayList<>(); + String fromNode = relation.getFromNode(); + String toNode = relation.getToNode(); + List relationships = relation.getRelationships(); + if (relationships == null || relationships.isEmpty()) { + BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement definition sent in order to set the relation between {} to {}", fromNode, toNode); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + JanusGraphOperationStatus.ILLEGAL_ARGUMENT)); + } + + for (CapabilityRequirementRelationship immutablePair : relationships) { + String requirement = immutablePair.getRelation().getRequirement(); + + Either, StorageOperationStatus> associateRes = connectInstancesInContainer(fromNode, toNode, immutablePair.getRelation(), relation.isOriginUI(), calculatedCapabilty, calculatedRequirement, + fullFilledCapabilty, fullfilledRequirement, compositionDataDefinition, containerV.getUniqueId()); + + if (associateRes.isRight()) { + status = associateRes.right().value(); + BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to associate resource instance {} to resource instance {}. status is {}", fromNode, toNode, status); + return Either.right(status); + } + + RelationshipInstDataDefinition relationshipInstData = (RelationshipInstDataDefinition) associateRes.left().value().get(JsonPresentationFields.RELATIONSHIP); + RelationshipImpl relationshipImplResult = new RelationshipImpl(); + relationshipImplResult.setType(relationshipInstData.getType()); + RelationshipInfo requirementAndRelationshipPair = new RelationshipInfo(requirement, relationshipImplResult); + requirementAndRelationshipPair.setCapability(immutablePair.getRelation().getCapability()); + requirementAndRelationshipPair.setRequirement(immutablePair.getRelation().getRequirement()); + requirementAndRelationshipPair.setCapabilityOwnerId(relationshipInstData.getCapabilityOwnerId()); + requirementAndRelationshipPair.setRequirementOwnerId(relationshipInstData.getRequirementOwnerId()); + requirementAndRelationshipPair.setCapabilityUid(immutablePair.getRelation().getCapabilityUid()); + requirementAndRelationshipPair.setRequirementUid(immutablePair.getRelation().getRequirementUid()); + requirementAndRelationshipPair.setId(relationshipInstData.getUniqueId()); + CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship(); + capReqRel.setRelation(requirementAndRelationshipPair); + capReqRel.setCapability((CapabilityDataDefinition) associateRes.left().value().get(JsonPresentationFields.CAPABILITY)); + capReqRel.setRequirement((RequirementDataDefinition) associateRes.left().value().get(JsonPresentationFields.REQUIREMENT)); + relationshipsResult.add(capReqRel); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "update customization UUID for from CI {} and to CI {}", relation.getFromNode(), relation.getToNode()); + status = updateCustomizationUUID(relation.getFromNode(), compositionDataDefinition); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + status = updateCustomizationUUID(relation.getToNode(), compositionDataDefinition); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + RequirementCapabilityRelDef reqCapRelDef = new RequirementCapabilityRelDef(relation); + reqCapRelDef.setRelationships(relationshipsResult); + relationsList.add(reqCapRelDef); + } + // update metadata of container and composition json + status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + + return Either.left(relationsList); + } + + private StorageOperationStatus updateAllAndCalculatedCapReqOnGraph(String componentId, GraphVertex containerV, Either>, StorageOperationStatus> capResult, + Either>, StorageOperationStatus> capFullResult, Either>, StorageOperationStatus> reqResult, + Either>, StorageOperationStatus> reqFullResult) { + containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + Either updateElement = janusGraphDao.updateVertex(containerV); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new relations error {}. ", componentId, updateElement.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()); + } + // update cap/req jsons, fulfilled cap/req jsons!!!!! + Either status; + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated capabilty for container {}", containerV.getUniqueId()); + status = updateOrCopyOnUpdate(capResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (status.isRight()) { + JanusGraphOperationStatus error = status.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated capabilty for container {} error {}", containerV.getUniqueId(), error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated requirement for container {}", containerV.getUniqueId()); + status = updateOrCopyOnUpdate(reqResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (status.isRight()) { + JanusGraphOperationStatus error = status.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated requiremnt for container {} error {}", containerV.getUniqueId(), error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled capabilty for container {}", containerV.getUniqueId()); + status = updateOrCopyOnUpdate(capFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (status.isRight()) { + JanusGraphOperationStatus error = status.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled capabilty for container {} error {}", containerV.getUniqueId(), error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled requirement for container {}", containerV.getUniqueId()); + status = updateOrCopyOnUpdate(reqFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (status.isRight()) { + JanusGraphOperationStatus error = status.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled requirement for container {} error {}", containerV.getUniqueId(), error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + return StorageOperationStatus.OK; + } + + @SuppressWarnings({ "unchecked" }) + public Either dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { + if (requirementDef.getRelationships() == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No relation pair in request [ {} ]", requirementDef); + return Either.right(StorageOperationStatus.BAD_REQUEST); + } + + String fromResInstanceUid = requirementDef.getFromNode(); + String toResInstanceUid = requirementDef.getToNode(); + + Either containerVEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (containerVEither.isRight()) { + JanusGraphOperationStatus error = containerVEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + GraphVertex containerV = containerVEither.left().value(); + + // DE191707 - validations + Map jsonComposition = (Map) containerV.getJson(); + CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + Map componentInstances = compositionDataDefinition.getComponentInstances(); + ComponentInstanceDataDefinition ciFrom = componentInstances.get(fromResInstanceUid); + if (ciFrom == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "FROM instance {} isn't under container {}", fromResInstanceUid, componentId); + return Either.right(StorageOperationStatus.NOT_FOUND); + + } + ComponentInstanceDataDefinition ciTo = componentInstances.get(toResInstanceUid); + if (ciFrom == ciTo) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "TO instance {} isn't under container {}", toResInstanceUid, componentId); + return Either.right(StorageOperationStatus.NOT_FOUND); + + } + Map relations = compositionDataDefinition.getRelations(); + + List relationPairList = requirementDef.getRelationships(); + Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (capResult.isRight()) { + return Either.right(capResult.right().value()); + } + Map calculatedCapability = capResult.left().value().getRight(); + + Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (capResult.isRight()) { + return Either.right(capResult.right().value()); + + } + Map fulfilledCapability = capFullResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (reqResult.isRight()) { + return Either.right(reqResult.right().value()); + } + Map calculatedRequirement = reqResult.left().value().getRight(); + + Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (reqResult.isRight()) { + return Either.right(reqResult.right().value()); + } + Map fulfilledRequirement = reqFullResult.left().value().getRight(); + + for (CapabilityRequirementRelationship relationPair : relationPairList) { + Iterator> iterator = relations.entrySet().iterator(); + boolean isDeleted = false; + while (iterator.hasNext()) { + Entry entryInJson = iterator.next(); + RelationshipInstDataDefinition relationInJson = entryInJson.getValue(); + if (relationInJson.getFromId().equals(fromResInstanceUid) && relationInJson.getToId().equals(toResInstanceUid) && relationInJson.getUniqueId().equals(relationPair.getRelation().getId())) { + if (relationPair.getRelation().equalsTo(relationInJson)) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Remove relation from {} to {} capability {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationInJson.getType(), relationInJson.getCapabilityOwnerId(), + relationInJson.getRequirementOwnerId()); + iterator.remove(); + + // update calculated cap/req + StorageOperationStatus status = updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapability, fulfilledCapability, toResInstanceUid, relationInJson, relationPair); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + status = updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fulfilledRequirement, fromResInstanceUid, relationInJson, relationPair); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + isDeleted = true; + } + } + } + if (!isDeleted) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No relation to delete from {} to {} capabilty {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationPair.getCapability(), + relationPair.getRelation().getCapabilityOwnerId(), relationPair.getRelation().getRequirementOwnerId()); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + } + StorageOperationStatus status = updateCustomizationUUID(fromResInstanceUid, compositionDataDefinition); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + status = updateCustomizationUUID(toResInstanceUid, compositionDataDefinition); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + + // update jsons + // update metadata of container and composition json + status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + + return Either.left(requirementDef); + } + + /** + * Retrieves fulfilled requirement according to relation and received predicate + * + * @param componentId + * @param instanceId + * @param foundRelation + * @param predicate + * @return + */ + public Either getFulfilledRequirementByRelation(String componentId, String instanceId, RequirementCapabilityRelDef foundRelation, + BiPredicate predicate) { + + Either result = null; + Either>, StorageOperationStatus> reqFullResult = null; + MapListRequirementDataDefinition reqMapOfLists = null; + Optional foundRequirement; + RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation(); + Either containerVEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (containerVEither.isRight()) { + JanusGraphOperationStatus error = containerVEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + if (result == null) { + GraphVertex containerV = containerVEither.left().value(); + reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (reqFullResult.isRight()) { + result = Either.right(reqFullResult.right().value()); + } + } + if (result == null) { + Map fulfilledRequirement = reqFullResult.left().value().getRight(); + reqMapOfLists = fulfilledRequirement.get(instanceId); + if (reqMapOfLists == null) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + if (result == null && reqMapOfLists != null) { + for (ListRequirementDataDefinition requirements : reqMapOfLists.getMapToscaDataDefinition().values()) { + foundRequirement = requirements.getListToscaDataDefinition().stream().filter(req -> predicate.test(relationshipInfo, req)).findFirst(); + if (foundRequirement.isPresent()) { + result = Either.left(foundRequirement.get()); + } + } + } + return result; + } + + /** + * Retrieves fulfilled capability according to relation and received predicate + * + * @param componentId + * @param instanceId + * @param foundRelation + * @param predicate + * @return + */ + public Either getFulfilledCapabilityByRelation(String componentId, String instanceId, RequirementCapabilityRelDef foundRelation, + BiPredicate predicate) { + + Either result = null; + Either>, StorageOperationStatus> capFullResult = null; + MapListCapabilityDataDefinition capMapOfLists = null; + Optional foundRequirement; + + RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation(); + Either containerVEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (containerVEither.isRight()) { + JanusGraphOperationStatus error = containerVEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + if (result == null) { + GraphVertex containerV = containerVEither.left().value(); + capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (capFullResult.isRight()) { + result = Either.right(capFullResult.right().value()); + } + } + if (result == null) { + Map fulfilledCapability = capFullResult.left().value().getRight(); + capMapOfLists = fulfilledCapability.get(instanceId); + if (capMapOfLists == null) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + if (result == null && capMapOfLists != null) { + for (ListCapabilityDataDefinition capabilities : capMapOfLists.getMapToscaDataDefinition().values()) { + foundRequirement = capabilities.getListToscaDataDefinition().stream().filter(cap -> predicate.test(relationshipInfo, cap)).findFirst(); + if (foundRequirement.isPresent()) { + result = Either.left(foundRequirement.get()); + } + } + } + return result; + } + + private StorageOperationStatus updateCalculatedRequirementsAfterDeleteRelation(Map calculatedRequirement, Map fullFilledRequirement, String fromResInstanceUid, + RelationshipInstDataDefinition relation, CapabilityRequirementRelationship relationship) { + StorageOperationStatus status; + String hereIsTheKey = null; + MapListRequirementDataDefinition reqByInstance = calculatedRequirement.get(fromResInstanceUid); + if (reqByInstance == null || reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()) == null) { + // move from fulfilled + status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation, hereIsTheKey, relationship); + } else { + hereIsTheKey = reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()); + ListRequirementDataDefinition reqByType = reqByInstance.findByKey(hereIsTheKey); + Optional requirementOptional = reqByType.getListToscaDataDefinition().stream() + .filter(req -> req.getOwnerId().equals(relation.getRequirementOwnerId()) && req.getName().equals(relation.getRequirement()) && req.getUniqueId().equals(relation.getRequirementId())).findFirst(); + + if (requirementOptional.isPresent()) { + + RequirementDataDefinition requirement = requirementOptional.get(); + String leftOccurrences = requirement.getLeftOccurrences(); + if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) { + Integer leftIntValue = Integer.parseInt(leftOccurrences); + ++leftIntValue; + requirement.setLeftOccurrences(String.valueOf(leftIntValue)); + } + if (relationship != null) { + relationship.setRequirement(requirement); + } + status = StorageOperationStatus.OK; + } else { + // move from fulfilled + status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation, hereIsTheKey, relationship); + } + } + return status; + } + + private StorageOperationStatus updateCalculatedCapabiltyAfterDeleteRelation(Map calculatedCapability, Map fullFilledCapability, String toResInstanceUid, + RelationshipInstDataDefinition relation, CapabilityRequirementRelationship relationship) { + StorageOperationStatus status; + String hereIsTheKey = null; + MapListCapabilityDataDefinition capByInstance = calculatedCapability.get(toResInstanceUid); + if (capByInstance == null || capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()) == null) { + // move from fulfilled + status = moveFromFullFilledCapabilty(calculatedCapability, fullFilledCapability, toResInstanceUid, relation, hereIsTheKey, relationship); + } else { + hereIsTheKey = capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()); + ListCapabilityDataDefinition capByType = capByInstance.findByKey(hereIsTheKey); + Optional capabilityOptional = capByType.getListToscaDataDefinition().stream().filter(cap -> cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getUniqueId().equals(relation.getCapabilityId())) + .findFirst(); + + if (capabilityOptional.isPresent()) { + + CapabilityDataDefinition capability = capabilityOptional.get(); + String leftOccurrences = capability.getLeftOccurrences(); + if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { + Integer leftIntValue = Integer.parseInt(leftOccurrences); + ++leftIntValue; + capability.setLeftOccurrences(String.valueOf(leftIntValue)); + } + if (relationship != null) { + relationship.setCapability(capability); + } + status = StorageOperationStatus.OK; + } else { + // move from fulfilled + status = moveFromFullFilledCapabilty(calculatedCapability, fullFilledCapability, toResInstanceUid, relation, hereIsTheKey, relationship); + } + } + return status; + } + + private StorageOperationStatus moveFromFullFilledCapabilty(Map calculatedCapability, Map fullFilledCapability, String toResInstanceUid, + RelationshipInstDataDefinition relation, String hereIsTheKey, CapabilityRequirementRelationship relationship) { + MapListCapabilityDataDefinition capByInstance = fullFilledCapability.get(toResInstanceUid); + if (capByInstance == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability in fulfilled list for instance {} ", toResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + if (null == hereIsTheKey) + hereIsTheKey = capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()); + if (null == hereIsTheKey) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability with id {} in fulfilled list for instance {} ", relation.getCapabilityId(), toResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + ListCapabilityDataDefinition capByType = capByInstance.findByKey(hereIsTheKey); + Iterator iterator = capByType.getListToscaDataDefinition().iterator(); + boolean found = false; + while (iterator.hasNext()) { + CapabilityDataDefinition cap = iterator.next(); + if (cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getUniqueId().equals(relation.getCapabilityId())) { + found = true; + iterator.remove(); + // return to calculated list + String leftOccurrences = cap.getLeftOccurrences(); + Integer leftIntValue = Integer.parseInt(leftOccurrences); + ++leftIntValue; + cap.setLeftOccurrences(String.valueOf(leftIntValue)); + + MapListCapabilityDataDefinition mapListCapaDataDef = calculatedCapability.get(toResInstanceUid); + if (mapListCapaDataDef == null) { + mapListCapaDataDef = new MapListCapabilityDataDefinition(); + } + ListCapabilityDataDefinition findByKey = mapListCapaDataDef.findByKey(hereIsTheKey); + if (findByKey == null) { + findByKey = new ListCapabilityDataDefinition(); + mapListCapaDataDef.put(hereIsTheKey, findByKey); + } + findByKey.add(cap); + if (relationship != null) + relationship.setCapability(cap); + break; + } + } + if (!found) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability type {} with ownerId {} in fulfilled list for instance {} ", hereIsTheKey, relation.getCapabilityOwnerId(), toResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus moveFromFullFilledRequirement(Map calculatedRequirement, Map fullFilledRequirement, String fromResInstanceUid, + RelationshipInstDataDefinition relation, String hereIsTheKey, CapabilityRequirementRelationship relationship) { + MapListRequirementDataDefinition reqByInstance = fullFilledRequirement.get(fromResInstanceUid); + if (reqByInstance == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement in fullfilled list for instance {} ", fromResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + if (null == hereIsTheKey) + hereIsTheKey = reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()); + if (null == hereIsTheKey) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement with id {} in fulfilled list for instance {} ", relation.getRequirementId(), fromResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + ListRequirementDataDefinition reqByType = reqByInstance.findByKey(hereIsTheKey); + Iterator iterator = reqByType.getListToscaDataDefinition().iterator(); + boolean found = false; + while (iterator.hasNext()) { + RequirementDataDefinition req = iterator.next(); + if (req.getOwnerId().equals(relation.getRequirementOwnerId()) && req.getName().equals(relation.getRequirement()) && req.getUniqueId().equals(relation.getRequirementId())) { + found = true; + iterator.remove(); + // return to calculated list + String leftOccurrences = req.getLeftOccurrences(); + Integer leftIntValue = Integer.parseInt(leftOccurrences); + ++leftIntValue; + req.setLeftOccurrences(String.valueOf(leftIntValue)); + + MapListRequirementDataDefinition mapListReqDataDef = calculatedRequirement.get(fromResInstanceUid); + if (mapListReqDataDef == null) { + mapListReqDataDef = new MapListRequirementDataDefinition(); + } + ListRequirementDataDefinition findByKey = mapListReqDataDef.findByKey(hereIsTheKey); + if (findByKey == null) { + findByKey = new ListRequirementDataDefinition(); + mapListReqDataDef.put(hereIsTheKey, findByKey); + } + findByKey.add(req); + if (relationship != null) + relationship.setRequirement(req); + break; + } + } + if (!found) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement type {} with ownerId {} in fulfilled list for instance {} ", hereIsTheKey, relation.getRequirementOwnerId(), fromResInstanceUid); + return StorageOperationStatus.GENERAL_ERROR; + } + return StorageOperationStatus.OK; + + } + + public StorageOperationStatus updateCustomizationUUID(String componentInstanceId, CompositionDataDefinition compositionDataDefinition) { + ComponentInstanceDataDefinition componentInstance = compositionDataDefinition.getComponentInstances().get(componentInstanceId); + + if (componentInstance == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component instance by id {} from map of instances ", componentInstanceId); + return StorageOperationStatus.NOT_FOUND; + } + UUID uuid = UUID.randomUUID(); + componentInstance.setCustomizationUUID(uuid.toString()); + + return StorageOperationStatus.OK; + } + + public Either, StorageOperationStatus> connectInstancesInContainer(String fromResInstanceUid, String toResInstanceUid, RelationshipInfo relationPair, boolean originUI, + Map calculatedCapabilty, Map calculatedRequirement, Map fullfilledCapabilty, + Map fullfilledRequirement, CompositionDataDefinition compositionDataDefinition, String containerId) { + String requirement = relationPair.getRequirement(); + Map componentInstances = compositionDataDefinition.getComponentInstances(); + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to associate resource instance {} to resource instance {} under component {}. Requirement is {}.", fromResInstanceUid, toResInstanceUid, containerId, requirement); + + ComponentInstanceDataDefinition fromResourceInstData = componentInstances.get(fromResInstanceUid); + if (fromResourceInstData == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find from resource instance {}.", fromResInstanceUid); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + ComponentInstanceDataDefinition toResourceInstData = componentInstances.get(toResInstanceUid); + if (toResourceInstData == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find to resource instance {}.", toResInstanceUid); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + + Either, StorageOperationStatus> reqVsCap = connectRequirementVsCapability(fromResourceInstData, toResourceInstData, relationPair, originUI, calculatedCapabilty, calculatedRequirement, fullfilledCapabilty, + fullfilledRequirement, containerId); + if (reqVsCap.isRight()) { + StorageOperationStatus status = reqVsCap.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to connect requirement {} between resource instance {} to resource instance {}. status is {}", requirement, fromResInstanceUid, toResInstanceUid, status); + return Either.right(status); + } + Map relationship = reqVsCap.left().value(); + + // add to json new relations + compositionDataDefinition.addRelation(((RelationshipInstDataDefinition) relationship.get(JsonPresentationFields.RELATIONSHIP)).getUniqueId(), (RelationshipInstDataDefinition) relationship.get(JsonPresentationFields.RELATIONSHIP)); + + return Either.left(relationship); + } + + private Either>, StorageOperationStatus> fetchContainerCalculatedCapability(GraphVertex containerV, EdgeLabelEnum capLabel) { + + Either>, JanusGraphOperationStatus> calculatedCapabiltyEither = getDataAndVertexFromGraph(containerV, capLabel); + if (calculatedCapabiltyEither.isRight()) { + JanusGraphOperationStatus error = calculatedCapabiltyEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilties for container {}.", containerV.getUniqueId(), error); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + Pair> calculatedCapabilty = calculatedCapabiltyEither.left().value(); + return Either.left(calculatedCapabilty); + } + + private Either>, StorageOperationStatus> fetchContainerCalculatedRequirement(GraphVertex containerV, EdgeLabelEnum reqLabel) { + Either>, JanusGraphOperationStatus> calculatedRequirementEither = getDataAndVertexFromGraph(containerV, reqLabel); + if (calculatedRequirementEither.isRight()) { + JanusGraphOperationStatus error = calculatedRequirementEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for container {}.", containerV.getUniqueId(), error); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + Pair> calculatedRequirement = calculatedRequirementEither.left().value(); + return Either.left(calculatedRequirement); + } + + @SuppressWarnings("unchecked") + private Either, StorageOperationStatus> connectRequirementVsCapability(ComponentInstanceDataDefinition fromResInstance, ComponentInstanceDataDefinition toResInstance, + RelationshipInfo relationPair, boolean originUI, Map calculatedCapabilty, Map calculatedRequirement, + Map fullfilledCapabilty, Map fullfilledRequirement, String containerId) { + String type = relationPair.getRelationship().getType(); + // capability + + String toInstId = toResInstance.getUniqueId(); + MapListCapabilityDataDefinition mapListCapabilityDataDefinition = calculatedCapabilty.get(toInstId); + Map capReqRelationship = new EnumMap<>(JsonPresentationFields.class); + + if (mapListCapabilityDataDefinition == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for instance {} in container {}.", toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + ListCapabilityDataDefinition listCapabilityDataDefinition = mapListCapabilityDataDefinition.getMapToscaDataDefinition().get(type); + if (listCapabilityDataDefinition == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for type {} for instance {} in container {}.", type, toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + CapabilityDataDefinition capabilityForRelation = null; + Iterator iteratorCap = listCapabilityDataDefinition.getListToscaDataDefinition().iterator(); + while (iteratorCap.hasNext()) { + CapabilityDataDefinition cap = iteratorCap.next(); + if (cap.getUniqueId().equals(relationPair.getCapabilityUid()) && cap.getOwnerId().equals(relationPair.getCapabilityOwnerId())) { + capabilityForRelation = cap; + capReqRelationship.put(JsonPresentationFields.CAPABILITY, (T) capabilityForRelation); + String leftOccurrences = cap.getLeftOccurrences(); + if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { + Integer leftIntValue = Integer.parseInt(leftOccurrences); + if (leftIntValue > 0) { + --leftIntValue; + capabilityForRelation.setLeftOccurrences(String.valueOf(leftIntValue)); + if (leftIntValue == 0) { + // remove from calculated + iteratorCap.remove(); + // move to fulfilled + MapListCapabilityDataDefinition mapListCapabiltyFullFilledInst = fullfilledCapabilty.get(toInstId); + if (mapListCapabiltyFullFilledInst == null) { + mapListCapabiltyFullFilledInst = new MapListCapabilityDataDefinition(); + fullfilledCapabilty.put(toInstId, mapListCapabiltyFullFilledInst); + } + + ListCapabilityDataDefinition listCapabilityFull = mapListCapabiltyFullFilledInst.findByKey(type); + if (listCapabilityFull == null) { + listCapabilityFull = new ListCapabilityDataDefinition(); + mapListCapabiltyFullFilledInst.put(type, listCapabilityFull); + } + listCapabilityFull.add(capabilityForRelation); + } + break; + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No left occurrences capabilty {} to {} in container {}.", capabilityForRelation.getType(), toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + } + } + } + if (capabilityForRelation == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch capabilty for type {} for instance {} in container {}.", type, toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + + // requirements + String fromInstId = fromResInstance.getUniqueId(); + MapListRequirementDataDefinition mapListRequirementDataDefinition = calculatedRequirement.get(fromInstId); + if (mapListRequirementDataDefinition == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for instance {} in container {}.", fromInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + ListRequirementDataDefinition listRequirementDataDefinition = mapListRequirementDataDefinition.getMapToscaDataDefinition().get(type); + if (listRequirementDataDefinition == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for type {} for instance {} in container {}.", type, fromInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + + RequirementDataDefinition requirementForRelation = null; + Iterator iteratorReq = listRequirementDataDefinition.getListToscaDataDefinition().iterator(); + while (iteratorReq.hasNext()) { + RequirementDataDefinition req = iteratorReq.next(); + if (req.getUniqueId().equals(relationPair.getRequirementUid()) && req.getOwnerId().equals(relationPair.getRequirementOwnerId())) { + requirementForRelation = req; + capReqRelationship.put(JsonPresentationFields.REQUIREMENT, (T) requirementForRelation); + String leftOccurrences = req.getLeftOccurrences(); + if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) { + Integer leftIntValue = Integer.parseInt(leftOccurrences); + if (leftIntValue > 0) { + --leftIntValue; + req.setLeftOccurrences(String.valueOf(leftIntValue)); + if (leftIntValue == 0) { + // remove from calculated + iteratorReq.remove(); + // move to fulfilled + MapListRequirementDataDefinition mapListRequirementFullFilledInst = fullfilledRequirement.get(fromInstId); + if (mapListRequirementFullFilledInst == null) { + mapListRequirementFullFilledInst = new MapListRequirementDataDefinition(); + fullfilledRequirement.put(fromInstId, mapListRequirementFullFilledInst); + } + + ListRequirementDataDefinition listRequirementFull = mapListRequirementFullFilledInst.findByKey(type); + if (listRequirementFull == null) { + listRequirementFull = new ListRequirementDataDefinition(); + mapListRequirementFullFilledInst.put(type, listRequirementFull); + } + listRequirementFull.add(requirementForRelation); + } + break; + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No left occurrences requirement {} from {} to {} in container {}.", requirementForRelation.getCapability(), fromInstId, toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + } + } + } + if (requirementForRelation == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch requirement for type {} for instance {} in container {}.", type, toInstId, containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + if (!capabilityForRelation.getType().equals(requirementForRelation.getCapability())) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No macth for capability from type {} and requirement {} from {} to {} in container {}.", capabilityForRelation.getType(), requirementForRelation.getCapability(), fromInstId, toInstId, + containerId); + return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); + } + + RelationshipInstDataDefinition relationshipTypeData = buildRelationshipInstData(fromInstId, toInstId, relationPair, originUI); + if (requirementForRelation.getRelationship() != null) + relationshipTypeData.setType(requirementForRelation.getRelationship()); + capReqRelationship.put(JsonPresentationFields.RELATIONSHIP, (T) relationshipTypeData); + return Either.left(capReqRelationship); + } + + private RelationshipInstDataDefinition buildRelationshipInstData(String fromResInstanceUid, String toInstId, RelationshipInfo relationPair, boolean originUI) { + + RelationshipInstDataDefinition relationshipInstData = new RelationshipInstDataDefinition(); + relationshipInstData.setUniqueId(UniqueIdBuilder.buildRelationsipInstInstanceUid(fromResInstanceUid, toInstId)); + + relationshipInstData.setType(relationPair.getRelationship().getType()); + Long creationDate = System.currentTimeMillis(); + relationshipInstData.setCreationTime(creationDate); + relationshipInstData.setModificationTime(creationDate); + relationshipInstData.setCapabilityOwnerId(relationPair.getCapabilityOwnerId()); + relationshipInstData.setRequirementOwnerId(relationPair.getRequirementOwnerId()); + relationshipInstData.setCapabilityId(relationPair.getCapabilityUid()); + relationshipInstData.setRequirementId(relationPair.getRequirementUid()); + relationshipInstData.setFromId(fromResInstanceUid); + relationshipInstData.setToId(toInstId); + relationshipInstData.setRequirement(relationPair.getRequirement()); + relationshipInstData.setCapability(relationPair.getCapability()); + relationshipInstData.setOriginUI(originUI); + + return relationshipInstData; + } + + public StorageOperationStatus associateComponentInstancesToComponent(Component containerComponent, Map componentInstanceTMap, GraphVertex containerVertex, boolean allowDeleted) { + + StorageOperationStatus result = null; + String containerId = containerComponent.getUniqueId(); + Map instancesJsonData = null; + Either updateElement = null; + if (!validateInstanceNames(componentInstanceTMap)) { + result = StorageOperationStatus.INCONSISTENCY; + } + if (result == null && !validateInstanceNames(componentInstanceTMap)) { + result = StorageOperationStatus.INCONSISTENCY; + } + if (result == null && !allowDeleted && !validateDeletedResources(componentInstanceTMap)) { + result = StorageOperationStatus.INCONSISTENCY; + } + if (result == null) { + instancesJsonData = convertToComponentInstanceDataDefinition(componentInstanceTMap, containerId); + } + if (result == null && MapUtils.isNotEmpty(instancesJsonData)) { + containerVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + Map compositions = new HashMap<>(); + CompositionDataDefinition composition = new CompositionDataDefinition(); + composition.setComponentInstances(instancesJsonData); + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition); + containerVertex.setJson(compositions); + updateElement = janusGraphDao.updateVertex(containerVertex); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instances. ", containerComponent.getName()); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()); + } + } + if (result == null && updateElement != null) { + GraphVertex vertexC = updateElement.left().value(); + instancesJsonData.entrySet().forEach(i ->createInstanceEdge(vertexC, i.getValue())); + result = StorageOperationStatus.OK; + } + return result; + } + + private Map convertToComponentInstanceDataDefinition(Map componentInstanceTMap, String containerId) { + + Map instances = new HashMap<>(); + for (Entry entry : componentInstanceTMap.entrySet()) { + ComponentInstanceDataDefinition instance = buildComponentInstanceDataDefinition(entry.getKey(), containerId, null, true, ModelConverter.convertToToscaElement(entry.getValue())); + instances.put(instance.getUniqueId(), instance); + } + return instances; + } + + private boolean validateDeletedResources(Map resourcesInstancesMap) { + boolean result = true; + for (Component component : resourcesInstancesMap.values()) { + if (component.getIsDeleted() != null && component.getIsDeleted()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance. ", component.getName()); + result = false; + break; + } + } + return result; + } + + private boolean validateInstanceNames(Map resourcesInstancesMap) { + boolean result = true; + Set names = new HashSet<>(); + for (ComponentInstance instance : resourcesInstancesMap.keySet()) { + if (StringUtils.isEmpty(instance.getName())) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component instance {} name is empty. Cannot add component instance. ", instance.getUniqueId()); + result = false; + break; + } else if (names.contains(instance.getName())) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component instance with the name {} already exsists. Cannot add component instance. ", instance.getName()); + result = false; + break; + } else { + names.add(instance.getName()); + } + } + return result; + } + + public StorageOperationStatus addDeploymentArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts) { + return addArtifactsToInstance(toscaElementId, instanceId, instDeplArtifacts, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS); + } + + public StorageOperationStatus addInformationalArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts) { + return addArtifactsToInstance(toscaElementId, instanceId, instDeplArtifacts, EdgeLabelEnum.INSTANCE_ARTIFACTS, VertexTypeEnum.INSTANCE_ARTIFACTS); + } + + public StorageOperationStatus addArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexType) { + Either metadataVertex = janusGraphDao + .getVertexById(toscaElementId, JsonParseFlagEnum.NoParse); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + MapArtifactDataDefinition instArtifacts = new MapArtifactDataDefinition(instDeplArtifacts); + return addToscaDataDeepElementsBlockToToscaElement(metadataVertex.left().value(), edgeLabel, vertexType, instArtifacts, instanceId); + + } + + @SuppressWarnings({ "unchecked" }) + public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) { + Either metadataVertex = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + GraphVertex metaVertex = metadataVertex.left().value(); + Map json = (Map) metaVertex.getJson(); + CompositionDataDefinition compositionDataDefinition = json.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + StorageOperationStatus status = updateCustomizationUUID(instanceId, compositionDataDefinition); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update customization UUID for instance {} in component {} error {}", instanceId, componentId, status); + return status; + } + Either updateVertex = janusGraphDao.updateVertex(metaVertex); + if (updateVertex.isRight()) { + log.debug("Failed to update vertex of component {} error {}", componentId, updateVertex.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateVertex.right().value()); + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List groupInstances) { + if (groupInstances != null) { + Either, JanusGraphOperationStatus> dataFromGraph = getDataFromGraph(componentId, EdgeLabelEnum.INST_GROUPS); + if (dataFromGraph.isRight()) { + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(dataFromGraph.right().value()); + } + MapGroupsDataDefinition grInstPerInstance = dataFromGraph.left().value().get(instanceId); + if (grInstPerInstance == null) { + log.debug("No instance groups for instance {} in component {}", instanceId, componentId); + return StorageOperationStatus.NOT_FOUND; + } + for (String instGroupForUpdate : groupInstances) { + GroupInstanceDataDefinition groupInst = grInstPerInstance.findByKey(instGroupForUpdate); + if (groupInst == null) { + log.debug("No group instance {} in group list for instance {} in component {}", instGroupForUpdate, instanceId, componentId); + continue; + } + UUID uuid = UUID.randomUUID(); + groupInst.setCustomizationUUID(uuid.toString()); + } + + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groupInstances) { + + return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, + new MapDataDefinition<>(groupInstances.stream().collect(Collectors.toMap(GroupInstanceDataDefinition::getName, gi -> gi))), componentInstance.getUniqueId()); + } + + public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map deploymentArtifacts) { + + return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, new MapDataDefinition<>(deploymentArtifacts), + componentInstance.getUniqueId()); + } + + public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { + + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus updateComponentInstanceCapabilityProperty(Component containerComponent, String componentInstanceId, String capabilityUniqueId, ComponentInstanceProperty property) { + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + pathKeys.add(capabilityUniqueId); + return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus overrideComponentCapabilitiesProperties(Component containerComponent, Map capabilityPropertyMap) { + return overrideToscaDataOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilityPropertyMap); + } + + public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus updateComponentInstanceProperties(Component containerComponent, String componentInstanceId, List properties) { + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return updateToscaDataDeepElementsOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, properties, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus updateComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus addComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { + + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus updateComponentInstanceInputs(Component containerComponent, String componentInstanceId, List properties) { + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return updateToscaDataDeepElementsOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, properties, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { + List pathKeys = new ArrayList<>(); + pathKeys.add(componentInstanceId); + return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME); + } + + public StorageOperationStatus createInstanceEdge(GraphVertex metadataVertex, ComponentInstanceDataDefinition componentInstance) { + String instUniqueId = componentInstance.getUniqueId(); + + // create edge between container and origin ( in case of proxy this edge will be to ProxyService node type) + StorageOperationStatus result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId).either(v -> StorageOperationStatus.OK, + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + + if (result == StorageOperationStatus.OK && componentInstance.getIsProxy()) { + // create edge between container and service origin + result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId) + .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + return result; + } + + public StorageOperationStatus createAllottedOfEdge(String componentId, String instanceId, String serviceUUID) { + Either vertexById = janusGraphDao.getVertexById(componentId); + if ( vertexById.isRight() ){ + log.debug("Failed to fetch component metadata vertex for id {} error {}", componentId, vertexById.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexById.right().value()); + } + GraphVertex metadataVertex = vertexById.left().value(); + + EnumMap props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.UUID, serviceUUID); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + EnumMap hasNot = new EnumMap<>(GraphPropertyEnum.class); + hasNot.put(GraphPropertyEnum.IS_DELETED, true); + + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao + .getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props,hasNot, JsonParseFlagEnum.ParseMetadata ); + if ( byCriteria.isRight() ){ + log.debug("Failed to fetch vertex by criteria {} error {}", props, byCriteria.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(byCriteria.right().value()); + } + List vertecies = byCriteria.left().value(); + StorageOperationStatus result = StorageOperationStatus.OK; + if ( vertecies != null ){ + GraphVertex serviceVertex = vertecies.get(0); + //remove previous edges + + log.debug("Try to create or update edge between resource {} and service {} ", metadataVertex, serviceVertex.getUniqueId()); + // create edge between container and service reference + result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.ALLOTTED_OF, serviceVertex.getUniqueId(), instanceId).either(v -> StorageOperationStatus.OK, + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + return result; + } + + + public StorageOperationStatus removeInstanceEdge(GraphVertex metadataVertex, ComponentInstanceDataDefinition componentInstance) { + String instUniqueId = componentInstance.getUniqueId(); + + // create edge between container and origin ( in case of proxy this edge will be to ProxyService node type) + StorageOperationStatus result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId) + .either(v -> StorageOperationStatus.OK, + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + + if (componentInstance.getIsProxy()) { + // create edge between container and service origin + result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId) + .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + return result; + } + + private Either createOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) { + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid); + + return janusGraphDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties) + .left() + .bind(v -> addInstanceToPropertyOnEdge(instUniqueId, v, metadataVertex)) + .right() + .bind(s -> createInstanceEdge(metadataVertex, edgeLabel, componentUid, instUniqueId, s)); + } + + private Either removeOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) { + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid); + + return janusGraphDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties).left().bind(v -> removeInstanceFromPropertyOnEdge(instUniqueId, v, metadataVertex)).right() + .map(err -> removeInstanceEdgeLogError(metadataVertex, edgeLabel, componentUid, err)); + } + + private Either addInstanceToPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) { + // edge exist need to add instance id to list on edge's property + List property = (List) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES); + if (property == null) { + property = new ArrayList<>(); + } + Optional findFirst = property.stream().filter(a -> a.equals(instUniqueId)).findFirst(); + if (!findFirst.isPresent()) { + property.add(instUniqueId); + } + try { + String jsonArr = JsonParserUtils.toJson(property); + log.debug("Update INSTANCES edge property with value {} ", jsonArr ); + + edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr); + } catch (IOException e) { + log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e ); + return Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + } + return Either.left(metadataVertex); + } + + private Either removeInstanceFromPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) { + // edge exist need to add instance id to list on edge's property + List property = (List) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES); + if (property == null) { + property = new ArrayList<>(); + } + Optional findFirst = property.stream().filter(a -> a.equals(instUniqueId)).findFirst(); + if (findFirst.isPresent()) { + property.remove(instUniqueId); + } + if (property.isEmpty()) { + // For last instance need to remove edge + edge.remove(); + } else { + try { + String jsonArr = JsonParserUtils.toJson(property); + edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr); + } catch (IOException e) { + log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e ); + return Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + } + } + return Either.left(metadataVertex); + } + + private Either createInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId, JanusGraphOperationStatus retrieveEdgeStatus) { + if (retrieveEdgeStatus == JanusGraphOperationStatus.NOT_FOUND) { + // create new edge + Either vertexById = janusGraphDao.getVertexById(componentUid); + if (vertexById.isRight()) { + return vertexById; + } + GraphVertex originVertex = vertexById.left().value(); + Map edgeProps = new EnumMap<>(EdgePropertyEnum.class); + List instList = new ArrayList<>(); + instList.add(instUniqueId); + edgeProps.put(EdgePropertyEnum.INSTANCES, instList); + + log.debug("Create new edge {} between {} and {} and properties {} ", edgeLabel, metadataVertex.getUniqueId(), originVertex.getUniqueId(), edgeProps); + JanusGraphOperationStatus + edgeResult = janusGraphDao + .createEdge(metadataVertex, originVertex, edgeLabel, edgeProps); + return edgeResult == JanusGraphOperationStatus.OK ? Either.left(metadataVertex) : Either.right(edgeResult); + } + // error + log.debug("Failed to fetch edge with label {} and to vertex with id {} error {} ", edgeLabel, componentUid, retrieveEdgeStatus); + return Either.right(retrieveEdgeStatus); + } + + private JanusGraphOperationStatus removeInstanceEdgeLogError(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, JanusGraphOperationStatus retrieveEdgeStatus) { + if (retrieveEdgeStatus == JanusGraphOperationStatus.NOT_FOUND) { + log.debug("No edge {} to remove between container {} and origin {}", edgeLabel, metadataVertex.getUniqueId(), componentUid); + } else { + // error + log.debug("Failed to fetch edge with label {} and to vertex with id {} error {} ", edgeLabel, componentUid, retrieveEdgeStatus); + } + return retrieveEdgeStatus; + } + + public void removeAllAllotedEdges(String uniqueId) { + Either vertexById = janusGraphDao.getVertexById(uniqueId); + if (vertexById.isLeft()) { + GraphVertex originVertex = vertexById.left().value(); + JanusGraphVertex vertex = originVertex.getVertex(); + Iterator edges = vertex.edges(Direction.OUT, EdgeLabelEnum.ALLOTTED_OF.name()); + while ( edges != null && edges.hasNext() ){ + Edge edge = edges.next(); + edge.remove(); + } + } + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTypeOperation.java new file mode 100644 index 0000000000..eb8b90332c --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTypeOperation.java @@ -0,0 +1,979 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.DerivedNodeTypeResolver; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.beans.factory.annotation.Qualifier; + +import java.util.*; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("node-type-operation") +public class NodeTypeOperation extends ToscaElementOperation { + public final static Pattern uuidNewVersion = Pattern.compile("^\\d{1,}.1"); + public final static Pattern uuidNormativeNewVersion = Pattern.compile("^\\d{1,}.0"); + private static final Logger log = Logger.getLogger(NodeTypeOperation.class); + private DerivedNodeTypeResolver derivedResourceResolver; + + + public NodeTypeOperation(@Qualifier("derived-resource-resolver") DerivedNodeTypeResolver derivedNodeTypeResolver) { + this.derivedResourceResolver = derivedNodeTypeResolver; + } + + public Either createNodeType(NodeType nodeType) { + + Either result = null; + + nodeType.generateUUID(); + + //Set missing props such as names, default lifecycle state, dates etc... + nodeType = getResourceMetaDataFromResource(nodeType); + + //Set unique ID + String resourceUniqueId = nodeType.getUniqueId(); + if (resourceUniqueId == null) { + resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId(); + nodeType.setUniqueId(resourceUniqueId); + } + + // get derived from resources + List derivedResources = null; + Either, StorageOperationStatus> derivedResourcesResult = findDerivedResources(nodeType); + if (derivedResourcesResult.isRight()) { + result = Either.right(derivedResourcesResult.right().value()); + return result; + } else { + derivedResources = derivedResourcesResult.left().value(); + } + + //Create Vertext Object and fill according to given NodeType + GraphVertex nodeTypeVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE); + fillToscaElementVertexData(nodeTypeVertex, nodeType, JsonParseFlagEnum.ParseAll); + + //Create Node Type in Graph + Either createdVertex = janusGraphDao.createVertex(nodeTypeVertex); + if (createdVertex.isRight()) { + JanusGraphOperationStatus status = createdVertex.right().value(); + log.error("Error returned after creating resource data node {}. status returned is ", nodeTypeVertex, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + nodeTypeVertex = createdVertex.left().value(); + + StorageOperationStatus assosiateCommon = assosiateCommonForToscaElement(nodeTypeVertex, nodeType, derivedResources); + if (assosiateCommon != StorageOperationStatus.OK) { + result = Either.right(assosiateCommon); + return result; + } + + StorageOperationStatus associateDerived = assosiateToDerived(nodeTypeVertex, derivedResources); + if (associateDerived != StorageOperationStatus.OK) { + result = Either.right(associateDerived); + return result; + } + StorageOperationStatus associateCategory = assosiateResourceMetadataToCategory(nodeTypeVertex, nodeType); + if (associateCategory != StorageOperationStatus.OK) { + result = Either.right(associateCategory); + return result; + } + + StorageOperationStatus associateAttributes = associateAttributesToResource(nodeTypeVertex, nodeType, derivedResources); + if (associateAttributes != StorageOperationStatus.OK) { + result = Either.right(associateAttributes); + return result; + } + + StorageOperationStatus associateRequirements = associateRequirementsToResource(nodeTypeVertex, nodeType, derivedResources); + if (associateRequirements != StorageOperationStatus.OK) { + result = Either.right(associateRequirements); + return result; + } + + StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(nodeTypeVertex, nodeType, derivedResources); + if (associateCapabilities != StorageOperationStatus.OK) { + result = Either.right(associateCapabilities); + return result; + } + StorageOperationStatus associateCapabilitiesProps = associateCapabilitiesPropertiesToResource(nodeTypeVertex, nodeType, derivedResources); + if (associateCapabilitiesProps != StorageOperationStatus.OK) { + result = Either.right(associateCapabilitiesProps); + return result; + } + + StorageOperationStatus associateInterfaces = associateInterfacesToResource(nodeTypeVertex, nodeType, derivedResources); + if (associateInterfaces != StorageOperationStatus.OK) { + result = Either.right(associateInterfaces); + return result; + } + + StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(nodeTypeVertex, nodeType, derivedResources); + if (addAdditionalInformation != StorageOperationStatus.OK) { + result = Either.right(addAdditionalInformation); + return result; + } + result = Either.left(nodeType); + return result; + + } + + private StorageOperationStatus associateInterfacesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.INTERFACE_ARTIFACTS); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map interfacArtsAll = dataFromDerived.left().value(); + + Map interfacArts = nodeType.getInterfaceArtifacts(); + if (interfacArts != null) { + interfacArtsAll.putAll(interfacArts); + } + if (!interfacArtsAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INTERFACE_ARTIFACTS, EdgeLabelEnum.INTERFACE_ARTIFACTS, interfacArtsAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + @Override + public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { + + Either componentByLabelAndId = getComponentByLabelAndId(uniqueId, ToscaElementTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata); + if (componentByLabelAndId.isRight()) { + return Either.right(componentByLabelAndId.right().value()); + } + GraphVertex componentV = componentByLabelAndId.left().value(); + + return getToscaElement(componentV, componentParametersView); + + } + + // ------------------------------------------------------------- + @Override + public Either getToscaElement(GraphVertex componentV, ComponentParametersView componentParametersView) { + NodeType toscaElement; + toscaElement = convertToComponent(componentV); + JanusGraphOperationStatus status = null; + if (!componentParametersView.isIgnoreUsers()) { + status = setCreatorFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = setLastModifierFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreProperties()) { + status = setResourcePropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK && status != JanusGraphOperationStatus.NOT_FOUND) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreAttributesFrom()) { + status = setResourceAttributesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreDerivedFrom()) { + status = setResourceDerivedFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreCategories()) { + status = setResourceCategoryFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreRequirements()) { + status = setResourceRequirementsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + log.error("Failed to set requirement of resource {}. status is {}", componentV.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreCapabilities()) { + status = setResourceCapabilitiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreArtifacts()) { + status = setArtifactsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreAdditionalInformation()) { + status = setAdditionalInformationFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreInterfaces()) { + status = setInterfacesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreAllVersions()) { + status = setAllVersions(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK && status != JanusGraphOperationStatus.NOT_FOUND) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreCapabiltyProperties()) { + status = setComponentCapPropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + return Either.left(toscaElement); + } + + private JanusGraphOperationStatus setComponentCapPropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES_PROPERTIES); + if (result.isLeft()) { + toscaElement.setCapabilitiesProperties(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setInterfacesFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE_ARTIFACTS); + if (result.isLeft()) { + toscaElement.setInterfaceArtifacts(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + protected JanusGraphOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { + return setResourceCapabilitiesFromGraph(componentV, (NodeType) toscaElement); + } + + private JanusGraphOperationStatus setResourceCapabilitiesFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES); + if (result.isLeft()) { + toscaElement.setCapabilities(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setResourceDerivedFromGraph(GraphVertex componentV, NodeType toscaElement) { + List derivedFromList = new ArrayList<>(); + + JanusGraphOperationStatus + listFromGraphStatus = findResourcesPathRecursively(componentV, derivedFromList); + if (JanusGraphOperationStatus.OK != listFromGraphStatus) { + return listFromGraphStatus; + } + + if (!derivedFromList.isEmpty()) { + if (derivedFromList.size() > 1) { + List lastDerivedFrom = new ArrayList<>(); + lastDerivedFrom.add(derivedFromList.get(1)); + toscaElement.setDerivedFrom(lastDerivedFrom); + toscaElement.setDerivedList(derivedFromList); + } else { + toscaElement.setDerivedFrom(null); + toscaElement.setDerivedList(derivedFromList); + } + + } + return JanusGraphOperationStatus.OK; + } + + protected JanusGraphOperationStatus findResourcesPathRecursively(GraphVertex nodeTypeV, List resourcesPathList) { + Either parentResourceRes = janusGraphDao + .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + resourcesPathList.add((String) nodeTypeV.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME)); + while (parentResourceRes.isLeft()) { + + GraphVertex parent = parentResourceRes.left().value(); + resourcesPathList.add((String) parent.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME)); + parentResourceRes = janusGraphDao + .getChildVertex(parent, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + } + JanusGraphOperationStatus operationStatus = parentResourceRes.right().value(); + + if (operationStatus != JanusGraphOperationStatus.NOT_FOUND) { + return operationStatus; + } else { + return JanusGraphOperationStatus.OK; + } + + } + + protected JanusGraphOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { + return setResourceRequirementsFromGraph(componentV, (NodeType) toscaElement); + } + + private JanusGraphOperationStatus setResourceRequirementsFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.REQUIREMENTS); + if (result.isLeft()) { + toscaElement.setRequirements(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setResourceAttributesFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ATTRIBUTES); + if (result.isLeft()) { + toscaElement.setAttributes(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setResourcePropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.PROPERTIES); + if (result.isLeft()) { + toscaElement.setProperties(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private StorageOperationStatus assosiateToDerived(GraphVertex nodeTypeVertex, List derivedResources) { + for (GraphVertex derivedV : derivedResources) { + JanusGraphOperationStatus + createEdge = janusGraphDao + .createEdge(nodeTypeVertex, derivedV, EdgeLabelEnum.DERIVED_FROM, null); + if (createEdge != JanusGraphOperationStatus.OK) { + log.trace("Failed to associate resource {} to derived with id {}", nodeTypeVertex.getUniqueId(), derivedV.getUniqueId()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus addAdditionalInformationToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ADDITIONAL_INFORMATION); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map addInformationAll = dataFromDerived.left().value(); + + Map addInformation = nodeType.getAdditionalInformation(); + if (addInformation != null) { + ToscaDataDefinition.mergeDataMaps(addInformationAll, addInformation); + } + if (!addInformationAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, addInformationAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateCapabilitiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map capabiltiesAll = dataFromDerived.left().value(); + + Map capabilties = nodeType.getCapabilities(); + if (capabilties != null) { + if (capabiltiesAll == null) { + capabiltiesAll = new HashMap<>(); + } + capabilties.values().forEach(l -> { + l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildCapabilityUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + }); + + ToscaDataDefinition.mergeDataMaps(capabiltiesAll, capabilties); + capabiltiesAll.values().forEach(l -> { + l.getListToscaDataDefinition().forEach(c -> { + List capabilitySources = c.getCapabilitySources(); + if (capabilitySources == null) { + capabilitySources = new ArrayList<>(); + } + capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); + c.setCapabilitySources(capabilitySources); + }); + }); + } + capabiltiesAll.values().forEach(l -> { + l.getListToscaDataDefinition().forEach(c -> { + List capabilitySources = c.getCapabilitySources(); + if (capabilitySources == null) { + capabilitySources = new ArrayList<>(); + } + capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); + c.setCapabilitySources(capabilitySources); + }); + }); + if (!capabiltiesAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES, EdgeLabelEnum.CAPABILITIES, capabiltiesAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateRequirementsToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.REQUIREMENTS); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map requirementsAll = dataFromDerived.left().value(); + + Map requirements = nodeType.getRequirements(); + if (requirements != null) { + if (requirementsAll == null) { + requirementsAll = new HashMap<>(); + } + requirements.values().forEach(l -> { + l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + }); + + ToscaDataDefinition.mergeDataMaps(requirementsAll, requirements); + + } + if (!requirementsAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.REQUIREMENTS, EdgeLabelEnum.REQUIREMENTS, requirementsAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateAttributesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ATTRIBUTES); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map attributesAll = dataFromDerived.left().value(); + + Map attributes = nodeType.getAttributes(); + if (attributes != null) { + attributes.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildAttributeUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + ToscaDataDefinition.mergeDataMaps(attributesAll, attributes); + } + if (!attributesAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ATTRIBUTES, EdgeLabelEnum.ATTRIBUTES, attributesAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + // TODO get from derived + private StorageOperationStatus associateCapabilitiesPropertiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { + // // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES_PROPERTIES); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map propertiesAll = dataFromDerived.left().value(); + Map capabiltiesProps = nodeType.getCapabilitiesProperties(); + if (capabiltiesProps != null) { + capabiltiesProps.values().forEach(l -> { + if (l.getMapToscaDataDefinition() != null && l.getMapToscaDataDefinition().values() != null) { + Collection mapToscaDataDefinition = l.getMapToscaDataDefinition().values(); + mapToscaDataDefinition.stream().filter(p -> p != null && p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + } + }); + ToscaDataDefinition.mergeDataMaps(propertiesAll, capabiltiesProps); + } + if (!propertiesAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, propertiesAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public Either, StorageOperationStatus> findDerivedResources(NodeType nodeType) { + + List derivedResources = new ArrayList<>(); + List derivedFromResources = nodeType.getDerivedFrom(); + if (derivedFromResources != null && !derivedFromResources.isEmpty()) { + + for (String parentResource : derivedFromResources) { + Either, JanusGraphOperationStatus> getParentResources = derivedResourceResolver.findDerivedResources(parentResource); + List resources = null; + if (getParentResources.isRight()) { + log.error("Cannot find parent resource by tosca resource name {} in the graph.", parentResource); + return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND); + + } else { + resources = getParentResources.left().value(); + if (resources == null || resources.size() == 0) { + log.error("Cannot find parent resource by tosca name {} in the graph. resources size is empty", parentResource); + return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND); + } else { + if (resources.size() > 1) { + return handleMultipleParent(parentResource, derivedResources, resources); + } else { + GraphVertex parentResourceData = resources.get(0); + derivedResources.add(parentResourceData); + } + } + + } + + } + } + return Either.left(derivedResources); + } + + Either, StorageOperationStatus> handleMultipleParent(String parentResource, List derivedResource, List fetchedDerivedResources) { + + Either, StorageOperationStatus> result = Either.left(derivedResource); + try { + fetchedDerivedResources.sort((d1, d2) -> { + return new Double(Double.parseDouble((String) d1.getMetadataProperty(GraphPropertyEnum.VERSION))).compareTo(Double.parseDouble((String) d2.getMetadataProperty(GraphPropertyEnum.VERSION))); + }); + + int actualHighestIndex = fetchedDerivedResources.size() - 1; + derivedResource.add(fetchedDerivedResources.get(actualHighestIndex)); + fetchedDerivedResources.remove(actualHighestIndex); + + StorageOperationStatus status = fixMultipleParent(fetchedDerivedResources); + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during handle multiple parent {}. Exception is {}", parentResource, e.getMessage()); + result = Either.right(StorageOperationStatus.GENERAL_ERROR); + } + return result; + } + + private StorageOperationStatus fixMultipleParent(List fetchedDerivedResources) { + StorageOperationStatus result = StorageOperationStatus.OK; + for (GraphVertex fetchedDerivedResource : fetchedDerivedResources) { + fetchedDerivedResource.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false); + Either updateVertexRes = janusGraphDao.updateVertex(fetchedDerivedResource); + if (updateVertexRes.isRight()) { + JanusGraphOperationStatus titatStatus = updateVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of node type {} to false. Status is {}", fetchedDerivedResource.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME), titatStatus); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus); + break; + } + } + return result; + } + + private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, NodeType nodeType) { + nodeTypeVertex.setLabel(VertexTypeEnum.NODE_TYPE); + + fillCommonMetadata(nodeTypeVertex, nodeType); + + return nodeTypeVertex; + } + + @Override + public Either deleteToscaElement(GraphVertex toscaElementVertex) { + Either nodeType = getToscaElement(toscaElementVertex, new ComponentParametersView()); + if (nodeType.isRight()) { + log.debug("Failed to fetch tosca element {} error {}", toscaElementVertex.getUniqueId(), nodeType.right().value()); + return nodeType; + } + JanusGraphOperationStatus status = disassociateAndDeleteCommonElements(toscaElementVertex); + if (status != JanusGraphOperationStatus.OK) { + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate capabilties for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES_PROPERTIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate capabilties properties for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.REQUIREMENTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ATTRIBUTES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate attributes for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INTERFACE_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate interface artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + toscaElementVertex.getVertex().remove(); + log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId()); + + return nodeType; + } + + @SuppressWarnings("unchecked") + @Override + public Either createToscaElement(ToscaElement toscaElement) { + return createNodeType((NodeType) toscaElement); + } + + @Override + protected JanusGraphOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { + return setResourceCategoryFromGraph(vertexComponent, toscaElement); + } + + @Override + protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { + return validateResourceCategory(toscaElementToUpdate, elementV); + } + + @Override + protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV) { + + NodeType nodeType = (NodeType) toscaElementToUpdate; + + List derivedFromResources = nodeType.getDerivedFrom(); + + // now supported only single derived from + if (derivedFromResources != null && !derivedFromResources.isEmpty() && derivedFromResources.get(0) != null) { + String firstDerived = derivedFromResources.get(0); + boolean derivedFromGenericType = null != nodeType.getDerivedFromGenericType(); + Either childVertex = janusGraphDao + .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + JanusGraphOperationStatus getchieldError = childVertex.right().value(); + log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchieldError); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getchieldError); + } + GraphVertex firstDerivedInChain = childVertex.left().value(); + + String firstCurrentDerived = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME); + if (!firstDerived.equals(firstCurrentDerived) || derivedFromGenericType) { + + Map propertiesToMatch = new HashMap<>(); + propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + + propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, firstDerived); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + Either, JanusGraphOperationStatus> getParentResources = janusGraphDao + .getByCriteria(VertexTypeEnum.NODE_TYPE, propertiesToMatch, JsonParseFlagEnum.NoParse); + + if (getParentResources.isRight()) { + JanusGraphOperationStatus error = getParentResources.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch derived by criteria {}. error {} ", propertiesToMatch, error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + // must be only one + GraphVertex newDerivedV = getParentResources.left().value().get(0); + return updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, newDerivedV, false); + } + } + return StorageOperationStatus.OK; + } + + /** + * + * @param toscaElementToUpdate + * @param nodeTypeV + * @param preDerivedV + * @param newDerivedV + * @param mergeValues + * @return + */ + protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV, GraphVertex preDerivedV, GraphVertex newDerivedV, boolean mergeValues) { + Set preDerivedChainIdList = new HashSet(); + preDerivedChainIdList.add(preDerivedV.getUniqueId()); + Either childVertex = janusGraphDao + .getChildVertex(preDerivedV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + while (childVertex.isLeft()) { + GraphVertex currentChield = childVertex.left().value(); + preDerivedChainIdList.add(currentChield.getUniqueId()); + childVertex = janusGraphDao + .getChildVertex(currentChield, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + } + + List derivedResources = new ArrayList<>(); + derivedResources.add(newDerivedV); + StorageOperationStatus updateStatus = updateDataFromNewDerived(derivedResources, nodeTypeV, (NodeType) toscaElementToUpdate, mergeValues, preDerivedChainIdList); + if (updateStatus != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update data for {} from new derived {} ", nodeTypeV.getUniqueId(), newDerivedV.getUniqueId(), updateStatus); + return updateStatus; + } + + Either deleteEdge = janusGraphDao + .deleteEdge(nodeTypeV, preDerivedV, EdgeLabelEnum.DERIVED_FROM); + if (deleteEdge.isRight()) { + JanusGraphOperationStatus deleteError = deleteEdge.right().value(); + log.debug("Failed to disassociate element {} from derived {} , error {}", nodeTypeV.getUniqueId(), preDerivedV.getUniqueId(), deleteError); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteError); + } + + janusGraphDao.createEdge(nodeTypeV, newDerivedV, EdgeLabelEnum.DERIVED_FROM, new HashMap<>()); + + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateDerivedDataByType(EdgeLabelEnum edgeLabel, GraphVertex nodeTypeV, NodeType nodeToUpdate, List newDerived) { + + switch (edgeLabel) { + case CAPABILITIES: + return associateCapabilitiesToResource(nodeTypeV, nodeToUpdate, newDerived); + case REQUIREMENTS: + return associateRequirementsToResource(nodeTypeV, nodeToUpdate, newDerived); + case PROPERTIES: + return associatePropertiesToResource(nodeTypeV, nodeToUpdate, newDerived); + case ATTRIBUTES: + return associateAttributesToResource(nodeTypeV, nodeToUpdate, newDerived); + case ADDITIONAL_INFORMATION: + return addAdditionalInformationToResource(nodeTypeV, nodeToUpdate, newDerived); + case CAPABILITIES_PROPERTIES: + return associateCapabilitiesPropertiesToResource(nodeTypeV, nodeToUpdate, newDerived); + default: + return StorageOperationStatus.OK; + } + + } + + private StorageOperationStatus updateDataFromNewDerived(List newDerived, GraphVertex nodeTypeV, NodeType nodeToUpdate, boolean mergeValues, Set preDerivedChainIdList) { + EnumSet edgeLabels = EnumSet.of(EdgeLabelEnum.CAPABILITIES, EdgeLabelEnum.REQUIREMENTS, EdgeLabelEnum.PROPERTIES, EdgeLabelEnum.ATTRIBUTES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.ADDITIONAL_INFORMATION); + StorageOperationStatus status = null; + for (EdgeLabelEnum edge : edgeLabels) { + status = updateDataByType(newDerived, nodeTypeV, edge, nodeToUpdate, mergeValues, preDerivedChainIdList); + if (status != StorageOperationStatus.OK) { + break; + } + } + return status; + + } + + private StorageOperationStatus updateDataByType(List newDerivedList, GraphVertex nodeTypeV, EdgeLabelEnum label, NodeType nodeElement, boolean mergeValues, Set preDerivedChainIdList) { + log.debug("Update data from derived for element {} type {}", nodeTypeV.getUniqueId(), label); + Either dataFromGraph = getDataVertex(nodeTypeV, label); + if (dataFromGraph.isRight()) { + if (JanusGraphOperationStatus.NOT_FOUND == dataFromGraph.right().value()) + return associateDerivedDataByType(label, nodeTypeV, nodeElement, newDerivedList); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(dataFromGraph.right().value()); + } + GraphVertex dataV = dataFromGraph.left().value(); + + Map mapFromGraph = (Map) dataV.getJson(); + Map valuesFrmPrev = null; + if (isSimpleHierarchy(label)) { + if (mergeValues) { + valuesFrmPrev = mapFromGraph.entrySet().stream().filter(e -> e.getValue().getOwnerId() != null).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + } + mapFromGraph.entrySet().removeIf(e -> preDerivedChainIdList.contains(e.getValue().getOwnerId())); + } else { + final Map valuesFrmPrevFinal = new HashMap<>(); + mapFromGraph.entrySet().stream().forEach(e -> { + T value = e.getValue(); + value = ToscaDataDefinition.removeAndCollectByOwnerId(value, preDerivedChainIdList); + valuesFrmPrevFinal.put(e.getKey(), value); + }); + valuesFrmPrev = valuesFrmPrevFinal; + mapFromGraph.entrySet().removeIf(e->e.getValue().isEmpty()); + } + + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(newDerivedList, label); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map dataFromDerivedAll = dataFromDerived.left().value(); + + Either, String> merged = ToscaDataDefinition.mergeDataMaps(dataFromDerivedAll, mapFromGraph); + if (merged.isRight()) { + log.debug("property {} cannot be overriden", merged.right().value()); + return StorageOperationStatus.INVALID_PROPERTY; + } + if (mergeValues && valuesFrmPrev != null) { + valuesFrmPrev.entrySet().forEach(e -> { + T newData = merged.left().value().get(e.getKey()); + if (newData != null) { + if (isSimpleHierarchy(label)) { + e.getValue().mergeFunction(newData, true); + }else{ + e.getValue().updateIfExist(newData, true); + } + } + }); + } + dataV.setJson(dataFromDerivedAll); + Either updateDataV = updateOrCopyOnUpdate(dataV, nodeTypeV, label); + if (updateDataV.isRight()) { + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateDataV.right().value()); + } + return StorageOperationStatus.OK; + } + + private boolean isSimpleHierarchy(EdgeLabelEnum label) { + switch (label) { + case PROPERTIES: + case ATTRIBUTES: + case ADDITIONAL_INFORMATION: + case ARTIFACTS: + case GROUPS: + case INPUTS: + return true; + default: + return false; + } + } + + @Override + public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { + fillMetadata(elementV, (NodeType) toscaElementToUpdate); + } + + public Either shouldUpdateDerivedVersion(ToscaElement toscaElementToUpdate, GraphVertex nodeTypeV) { + NodeType nodeType = (NodeType) toscaElementToUpdate; + + Either childVertex = janusGraphDao + .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + JanusGraphOperationStatus getchildError = childVertex.right().value(); + if (getchildError == JanusGraphOperationStatus.NOT_FOUND) { + log.debug("derived resource for element {} not found", nodeTypeV.getUniqueId()); + return Either.right(StorageOperationStatus.OK); + } + + log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchildError); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getchildError)); + } + GraphVertex firstDerivedInChain = childVertex.left().value(); + + String currentVersion = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.VERSION); + + Map props = new HashMap<>(); + props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, nodeType.getDerivedFrom().get(0)); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + Map propsHasNot = new HashMap<>(); + propsHasNot.put(GraphPropertyEnum.IS_DELETED, true); + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao + .getByCriteria(VertexTypeEnum.NODE_TYPE, props, propsHasNot, JsonParseFlagEnum.NoParse); + if (byCriteria.isRight()) { + log.debug("Failed to fetch derived by props {} error {}", props, byCriteria.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(byCriteria.right().value())); + } + List lastDerived = byCriteria.left().value(); + // now supported only one derived!!! Change in future!(Evg) + GraphVertex derivedFromHighest = lastDerived.get(0); + String highestVersion = (String) derivedFromHighest.getMetadataProperty(GraphPropertyEnum.VERSION); + if (!highestVersion.equals(currentVersion)) { + + // need to update to latest version of derived from + StorageOperationStatus updateDerived = updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, derivedFromHighest, true); + + if (updateDerived != StorageOperationStatus.OK) { + log.debug("Failed to update {} to highest derived {} from error {}", nodeTypeV.getUniqueId(), derivedFromHighest.getUniqueId(), updateDerived); + return Either.right(updateDerived); + } + return getToscaElement(nodeTypeV.getUniqueId(), new ComponentParametersView()); + } + // no version changes + return Either.right(StorageOperationStatus.OK); + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperation.java new file mode 100644 index 0000000000..349ea809e7 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperation.java @@ -0,0 +1,62 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.utils.MapUtil; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.common.log.wrappers.Logger; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@org.springframework.stereotype.Component +public class PolicyOperation { + + private static final Logger log = Logger.getLogger(PolicyOperation.class.getName()); + private TopologyTemplateOperation topologyTemplateOperation; + private JanusGraphDao janusGraphDao; + + public PolicyOperation(TopologyTemplateOperation topologyTemplateOperation, JanusGraphDao janusGraphDao) { + this.topologyTemplateOperation = topologyTemplateOperation; + this.janusGraphDao = janusGraphDao; + } + + /** + * updates a list of policy properties by overriding the existing ones with the same name + * @param containerComponent the container of the policy of which its properties are to be updated + * @param policyId the id of the policy of which its properties are to be updated + * @param propertiesToUpdate the policy properties to update + * @return the update operation status + */ + public StorageOperationStatus updatePolicyProperties(Component containerComponent, String policyId, List propertiesToUpdate) { + log.debug("#updatePolicyProperties - updating the properties of policy {} in component {}", policyId, containerComponent.getUniqueId()); + PolicyDefinition policy = containerComponent.getPolicyById(policyId); + return janusGraphDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse) + .either(containerVertex -> updatePolicyProperties(containerVertex, policy, propertiesToUpdate), + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + private StorageOperationStatus updatePolicyProperties(GraphVertex container, PolicyDefinition policy, List propertiesToUpdate) { + List policyProperties = policy.getProperties(); + List updatedPolicyProperties = updatePolicyProperties(policyProperties, propertiesToUpdate); + policy.setProperties(updatedPolicyProperties); + return topologyTemplateOperation.updatePolicyOfToscaElement(container, policy); + } + + private List updatePolicyProperties(List currentPolicyProperties, List toBeUpdatedProperties) { + Map currPropsByName = MapUtil.toMap(currentPolicyProperties, PropertyDataDefinition::getName); + overrideCurrentPropertiesWithUpdatedProperties(currPropsByName, toBeUpdatedProperties); + return new ArrayList<>(currPropsByName.values()); + } + + private void overrideCurrentPropertiesWithUpdatedProperties(Map currPropsByName, List toBeUpdatedProperties) { + toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop)); + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/RequirementOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/RequirementOperation.java new file mode 100644 index 0000000000..9c1d1eec3b --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/RequirementOperation.java @@ -0,0 +1,92 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.RequirementDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@org.springframework.stereotype.Component("requirement-operation") +public class RequirementOperation extends BaseOperation { + private static final Logger LOGGER = LoggerFactory.getLogger(RequirementOperation.class); + + public Either, StorageOperationStatus> addRequirement( + String componentId, + List requirementDefinitions) { + return addOrUpdateRequirements( componentId, requirementDefinitions, false); + } + + public Either, StorageOperationStatus> updateRequirement( + String componentId, + List requirementDefinitions) { + return addOrUpdateRequirements( componentId, requirementDefinitions, true); + } + + + private Either, StorageOperationStatus> addOrUpdateRequirements(String componentId, + List requirementDefinitions, + boolean isUpdateAction) { + + StorageOperationStatus statusRes = performUpdateToscaAction(isUpdateAction, + componentId, Collections + .singletonList(convertToListRequirementDataDefinition(requirementDefinitions))); + if (!statusRes.equals(StorageOperationStatus.OK)) { + janusGraphDao.rollback(); + LOGGER.error("Failed to find the parent capability of capability type {}." + + " status is {}", componentId, statusRes); + return Either.right(statusRes); + } + janusGraphDao.commit(); + return Either.left(requirementDefinitions); + } + + public StorageOperationStatus deleteRequirements(Component component, + String requirementToDelete) { + return deleteToscaDataElements(component.getUniqueId(), + EdgeLabelEnum.REQUIREMENTS, Collections.singletonList(requirementToDelete)); + } + + private static ListRequirementDataDefinition convertToListRequirementDataDefinition( + List requirementDefinitions) { + List requirementDataDefinitions = + new ArrayList<>(requirementDefinitions); + return new ListRequirementDataDefinition(requirementDataDefinitions); + } + + private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, + String componentId, List toscaDataList) { + if (isUpdate) { + return updateToscaDataOfToscaElement(componentId, EdgeLabelEnum.REQUIREMENTS, + VertexTypeEnum.REQUIREMENTS, toscaDataList, JsonPresentationFields.CAPABILITY); + } else { + return addToscaDataToToscaElement(componentId, EdgeLabelEnum.REQUIREMENTS, + VertexTypeEnum.REQUIREMENTS, toscaDataList, JsonPresentationFields.CAPABILITY); + } + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperation.java new file mode 100644 index 0000000000..a429033505 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperation.java @@ -0,0 +1,1623 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import com.google.gson.reflect.TypeToken; +import fj.data.Either; +import org.apache.commons.collections.MapUtils; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.DistributionStatusEnum; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.CapabilityRequirementNameResolver; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +import org.openecomp.sdc.be.model.operations.StorageException; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.springframework.beans.factory.annotation.Autowired; + +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("topology-template-operation") +public class TopologyTemplateOperation extends ToscaElementOperation { + + private static final Logger log = Logger.getLogger(TopologyTemplateOperation.class); + private Set nodeTypeSet = new HashSet<>(Arrays.asList(OriginTypeEnum.VFC, OriginTypeEnum.CP, OriginTypeEnum.VL, OriginTypeEnum.Configuration, OriginTypeEnum.VFCMT)); + + @Autowired + private ArchiveOperation archiveOperation; + + public Either createTopologyTemplate(TopologyTemplate topologyTemplate) { + Either result = null; + + topologyTemplate.generateUUID(); + + topologyTemplate = getResourceMetaDataFromResource(topologyTemplate); + String resourceUniqueId = topologyTemplate.getUniqueId(); + if (resourceUniqueId == null) { + resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId(); + topologyTemplate.setUniqueId(resourceUniqueId); + } + + GraphVertex topologyTemplateVertex = new GraphVertex(); + topologyTemplateVertex = fillMetadata(topologyTemplateVertex, topologyTemplate, JsonParseFlagEnum.ParseAll); + + Either createdVertex = janusGraphDao.createVertex(topologyTemplateVertex); + if (createdVertex.isRight()) { + JanusGraphOperationStatus status = createdVertex.right().value(); + log.debug("Error returned after creating topology template data node {}. status returned is ", topologyTemplateVertex, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + + topologyTemplateVertex = createdVertex.left().value(); + + StorageOperationStatus assosiateCommon = assosiateCommonForToscaElement(topologyTemplateVertex, topologyTemplate, null); + if (assosiateCommon != StorageOperationStatus.OK) { + result = Either.right(assosiateCommon); + return result; + } + + StorageOperationStatus associateCategory = assosiateMetadataToCategory(topologyTemplateVertex, topologyTemplate); + if (associateCategory != StorageOperationStatus.OK) { + result = Either.right(associateCategory); + return result; + } + + StorageOperationStatus associateInputs = associateInputsToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInputs != StorageOperationStatus.OK) { + result = Either.right(associateInputs); + return result; + } + StorageOperationStatus associateGroups = associateGroupsToComponent(topologyTemplateVertex, topologyTemplate); + if (associateGroups != StorageOperationStatus.OK) { + result = Either.right(associateGroups); + return result; + } + StorageOperationStatus associatePolicies = associatePoliciesToComponent(topologyTemplateVertex, topologyTemplate); + if (associatePolicies != StorageOperationStatus.OK) { + result = Either.right(associatePolicies); + return result; + } + StorageOperationStatus associateInstAttr = associateInstAttributesToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInstAttr != StorageOperationStatus.OK) { + result = Either.right(associateInstAttr); + return result; + } + StorageOperationStatus associateInstProperties = associateInstPropertiesToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInstProperties != StorageOperationStatus.OK) { + result = Either.right(associateInstProperties); + return result; + } + StorageOperationStatus associateInstInputs = associateInstInputsToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInstProperties != StorageOperationStatus.OK) { + result = Either.right(associateInstInputs); + return result; + } + StorageOperationStatus associateInstGroups = associateInstGroupsToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInstGroups != StorageOperationStatus.OK) { + result = Either.right(associateInstInputs); + return result; + } + + StorageOperationStatus associateRequirements = associateRequirementsToResource(topologyTemplateVertex, topologyTemplate); + if (associateRequirements != StorageOperationStatus.OK) { + result = Either.right(associateRequirements); + return result; + } + + StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(topologyTemplateVertex, topologyTemplate); + if (associateCapabilities != StorageOperationStatus.OK) { + result = Either.right(associateCapabilities); + return result; + } + + StorageOperationStatus associateArtifacts = associateTopologyTemplateArtifactsToComponent(topologyTemplateVertex, topologyTemplate); + if (associateArtifacts != StorageOperationStatus.OK) { + result = Either.right(associateArtifacts); + return result; + } + + StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(topologyTemplateVertex, topologyTemplate); + if (addAdditionalInformation != StorageOperationStatus.OK) { + result = Either.right(addAdditionalInformation); + return result; + } + StorageOperationStatus associateCapProperties = associateCapPropertiesToResource(topologyTemplateVertex, topologyTemplate); + if (associateCapProperties != StorageOperationStatus.OK) { + result = Either.right(associateCapProperties); + return result; + } + + StorageOperationStatus associateInterfaces = associateInterfacesToComponent(topologyTemplateVertex, topologyTemplate); + if (associateInterfaces != StorageOperationStatus.OK) { + result = Either.right(associateInterfaces); + return result; + } + + StorageOperationStatus associatePathProperties = associateForwardingPathToResource(topologyTemplateVertex, topologyTemplate); + if (associateCapProperties != StorageOperationStatus.OK) { + result = Either.right(associatePathProperties); + return result; + } + + + return Either.left(topologyTemplate); + + } + + private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + return associatePoliciesToComponent(nodeTypeVertex, topologyTemplate.getPolicies()); + } + + private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, Map policies) { + if (policies != null && !policies.isEmpty()) { + policies.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.POLICIES, EdgeLabelEnum.POLICIES, policies); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateForwardingPathToResource(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { + Map forwardingPaths = topologyTemplate.getForwardingPaths(); + return associateForwardingPathToComponent(topologyTemplateVertex, forwardingPaths); + } + + private StorageOperationStatus associateNodeFilterToResource(GraphVertex topologyTemplateVertex, + TopologyTemplate topologyTemplate) { + Map nodeFilters = + topologyTemplate.getNodeFilterComponents(); + return associateNodeFiltersToComponent(topologyTemplateVertex, nodeFilters); + } + + private StorageOperationStatus associateCapPropertiesToResource(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { + Map calculatedCapProperties = topologyTemplate + .getCalculatedCapabilitiesProperties(); + if (MapUtils.isNotEmpty(calculatedCapProperties)) { + Either associateElementToData = associateElementToData + (topologyTemplateVertex, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, + EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, calculatedCapProperties); + if (associateElementToData.isRight()) { + return associateElementToData.right().value(); + } + } + + Map capabilitiesProperties = topologyTemplate.getCapabilitiesProperties(); + if (MapUtils.isNotEmpty(capabilitiesProperties)) { + Either associateElementToData = + associateElementToData(topologyTemplateVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, + EdgeLabelEnum.CAPABILITIES_PROPERTIES, capabilitiesProperties); + if (associateElementToData.isRight()) { + return associateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateCapabilitiesToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map calculatedCapabilities = topologyTemplate.getCalculatedCapabilities(); + if (calculatedCapabilities != null && !calculatedCapabilities.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, calculatedCapabilities); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map fullfilledCapabilities = topologyTemplate.getFullfilledCapabilities(); + if (fullfilledCapabilities != null && !fullfilledCapabilities.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_CAPABILITIES, EdgeLabelEnum.FULLFILLED_CAPABILITIES, fullfilledCapabilities); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map capabilities = topologyTemplate.getCapabilities(); + if(MapUtils.isNotEmpty(capabilities)) { + Either associateElementToData = + associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES, + EdgeLabelEnum.CAPABILITIES, capabilities); + if (associateElementToData.isRight()) { + return associateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + + } + + private StorageOperationStatus associateRequirementsToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map calculatedRequirements = topologyTemplate.getCalculatedRequirements(); + if (calculatedRequirements != null && !calculatedRequirements.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calculatedRequirements); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map fullfilledRequirements = topologyTemplate.getFullfilledRequirements(); + if (fullfilledRequirements != null && !fullfilledRequirements.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_REQUIREMENTS, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, fullfilledRequirements); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map requirements = topologyTemplate.getRequirements(); + if(MapUtils.isNotEmpty(requirements)) { + Either associateElementToData = + associateElementToData(nodeTypeVertex, VertexTypeEnum.REQUIREMENTS, + EdgeLabelEnum.REQUIREMENTS, requirements); + if (associateElementToData.isRight()) { + return associateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateTopologyTemplateArtifactsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map addInformation = topologyTemplate.getServiceApiArtifacts(); + + if (addInformation != null && !addInformation.isEmpty()) { + addInformation.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { + String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); + a.setUniqueId(uniqueId); + }); + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.SERVICE_API_ARTIFACTS, EdgeLabelEnum.SERVICE_API_ARTIFACTS, addInformation); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map instArtifacts = topologyTemplate.getInstDeploymentArtifacts(); + + if (instArtifacts != null && !instArtifacts.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, instArtifacts); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + Map instInfoArtifacts = topologyTemplate.getInstanceArtifacts(); + + if (instInfoArtifacts != null && !instInfoArtifacts.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INSTANCE_ARTIFACTS, EdgeLabelEnum.INSTANCE_ARTIFACTS, instInfoArtifacts); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus addAdditionalInformationToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + + Map addInformation = topologyTemplate.getAdditionalInformation(); + + if (addInformation != null && !addInformation.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, addInformation); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateInstPropertiesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map instProps = topologyTemplate.getInstProperties(); + return associateInstPropertiesToComponent(nodeTypeVertex, instProps); + } + + public StorageOperationStatus associateInstInputsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map instProps = topologyTemplate.getInstInputs(); + return associateInstInputsToComponent(nodeTypeVertex, instProps); + } + + public StorageOperationStatus associateInstGroupsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map instGroups = topologyTemplate.getInstGroups(); + return associateInstGroupsToComponent(nodeTypeVertex, instGroups); + } + + + public StorageOperationStatus associateInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map instProps) { + if (instProps != null && !instProps.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_PROPERTIES, EdgeLabelEnum.INST_PROPERTIES, instProps); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateInstInputsToComponent(GraphVertex nodeTypeVertex, Map instInputs) { + if (instInputs != null && !instInputs.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_INPUTS, EdgeLabelEnum.INST_INPUTS, instInputs); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateInstGroupsToComponent(GraphVertex nodeTypeVertex, Map instGroups) { + if (instGroups != null && !instGroups.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_GROUPS, EdgeLabelEnum.INST_GROUPS, instGroups); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + + public StorageOperationStatus deleteInstInputsToComponent(GraphVertex nodeTypeVertex, Map instInputs) { + + if (instInputs != null && !instInputs.isEmpty()) { + instInputs.entrySet().forEach(i -> { + List uniqueKeys = new ArrayList<>(i.getValue().getMapToscaDataDefinition().keySet()); + List pathKeys = new ArrayList<>(); + pathKeys.add(i.getKey()); + + StorageOperationStatus status = deleteToscaDataDeepElements(nodeTypeVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, uniqueKeys, pathKeys, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + return; + } + }); + } + + return StorageOperationStatus.OK; + } + + public StorageOperationStatus addInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map instInputs) { + + if (instInputs != null && !instInputs.isEmpty()) { + instInputs.entrySet().forEach(i -> { + StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(nodeTypeVertex, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, i.getValue(), i.getKey()); + if (status != StorageOperationStatus.OK) { + return; + } + }); + } + + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex, Map instArtifacts) { + return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + } + + public StorageOperationStatus associateInstArtifactsToComponent(GraphVertex nodeTypeVertex, Map instArtifacts) { + return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INSTANCE_ARTIFACTS, EdgeLabelEnum.INSTANCE_ARTIFACTS); + } + + private StorageOperationStatus associateInstanceArtifactsToComponent(GraphVertex nodeTypeVertex, Map instProps, VertexTypeEnum vertexType, EdgeLabelEnum edgeLabel) { + if (instProps != null && !instProps.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, vertexType, edgeLabel, instProps); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateOrAddCalcCapReqToComponent(GraphVertex nodeTypeVertex, Map calcRequirements, Map calcCapabilty, Map calculatedCapabilitiesProperties) { + if (calcRequirements != null && !calcRequirements.isEmpty()) { + Either assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calcRequirements); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + Map fullFilled = new HashMap<>(); + assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_REQUIREMENTS, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, fullFilled); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + if (calcCapabilty != null && !calcCapabilty.isEmpty()) { + Either assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, calcCapabilty); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + Map fullFilled = new HashMap<>(); + assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_CAPABILITIES, EdgeLabelEnum.FULLFILLED_CAPABILITIES, fullFilled); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + if (calculatedCapabilitiesProperties != null && !calculatedCapabilitiesProperties.isEmpty()) { + return associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, + EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, calculatedCapabilitiesProperties) + .right() + .on(v -> StorageOperationStatus.OK); + } + return StorageOperationStatus.OK; + } + + private Either associateOrAddElementToData(GraphVertex nodeTypeVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { + return janusGraphDao.getChildVertex(nodeTypeVertex, edgeLabelEnum, JsonParseFlagEnum.ParseJson) + .either(dataVertex -> addElementsToComponent(nodeTypeVertex, dataVertex, vertexTypeEnum, edgeLabelEnum, dataMap), + status -> associateElementToDataIfNotFound(status, nodeTypeVertex, vertexTypeEnum, edgeLabelEnum, dataMap)); + } + + private Either associateElementToDataIfNotFound(JanusGraphOperationStatus status, GraphVertex nodeTypeVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { + if (status == JanusGraphOperationStatus.NOT_FOUND) { + return associateElementToData(nodeTypeVertex, vertexTypeEnum, edgeLabelEnum, dataMap); + } + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + private Either addElementsToComponent(GraphVertex nodeTypeVertex, GraphVertex dataVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { + Optional error = dataMap.entrySet() + .stream() + .map(e -> addElementToComponent(nodeTypeVertex.getUniqueId(), vertexTypeEnum, edgeLabelEnum, e)) + .filter(s -> s != StorageOperationStatus.OK) + .findFirst(); + if (error.isPresent()) { + return Either.right(error.get()); + } + return Either.left(dataVertex); + } + + private StorageOperationStatus associateInstAttributesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map instAttr = topologyTemplate.getInstAttributes(); + return associateInstAttributeToComponent(nodeTypeVertex, instAttr); + } + + public StorageOperationStatus associateForwardingPathToComponent(GraphVertex nodeTypeVertex, Map forwardingPathMap) { + if (forwardingPathMap != null && !forwardingPathMap.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FORWARDING_PATH, EdgeLabelEnum.FORWARDING_PATH, forwardingPathMap); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateInstAttributeToComponent(GraphVertex nodeTypeVertex, Map instAttr) { + if (instAttr != null && !instAttr.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_ATTRIBUTES, EdgeLabelEnum.INST_ATTRIBUTES, instAttr); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateGroupsToComponent(GraphVertex nodeTypeVertex, Map groups) { + + if (groups != null && !groups.isEmpty()) { + groups.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.GROUPS, EdgeLabelEnum.GROUPS, groups); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateGroupsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + return associateGroupsToComponent(nodeTypeVertex, topologyTemplate.getGroups()); + } + + public StorageOperationStatus associateInputsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + Map inputs = topologyTemplate.getInputs(); + return associateInputsToComponent(nodeTypeVertex, inputs, topologyTemplate.getUniqueId()); + } + + public StorageOperationStatus associateInputsToComponent(GraphVertex nodeTypeVertex, Map inputs, String id) { + if (inputs != null && !inputs.isEmpty()) { + inputs.values().stream().filter(e -> e.getUniqueId() == null).forEach(e -> e.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(id, e.getName()))); + + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INPUTS, EdgeLabelEnum.INPUTS, inputs); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate, JsonParseFlagEnum flag) { + nodeTypeVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + fillCommonMetadata(nodeTypeVertex, topologyTemplate); + if (flag == JsonParseFlagEnum.ParseAll || flag == JsonParseFlagEnum.ParseJson) { + nodeTypeVertex.setJson(topologyTemplate.getCompositions()); + } + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.CSAR_UUID, topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, topologyTemplate.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)); + + return nodeTypeVertex; + + } + + private StorageOperationStatus assosiateMetadataToCategory(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + if (topologyTemplate.getResourceType() == null) { + // service + return associateServiceMetadataToCategory(nodeTypeVertex, topologyTemplate); + } else { + // VF + return assosiateResourceMetadataToCategory(nodeTypeVertex, topologyTemplate); + } + } + + private StorageOperationStatus associateServiceMetadataToCategory(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { + String categoryName = topologyTemplate.getCategories().get(0).getName(); + Either category = categoryOperation.getCategory(categoryName, VertexTypeEnum.SERVICE_CATEGORY); + if (category.isRight()) { + log.trace("NO category {} for service {}", categoryName, topologyTemplate.getUniqueId()); + return StorageOperationStatus.CATEGORY_NOT_FOUND; + } + GraphVertex categoryV = category.left().value(); + JanusGraphOperationStatus createEdge = janusGraphDao.createEdge(nodeTypeVertex, categoryV, EdgeLabelEnum.CATEGORY, new HashMap<>()); + if (createEdge != JanusGraphOperationStatus.OK) { + log.trace("Failed to associate resource {} to category {} with id {}", topologyTemplate.getUniqueId(), categoryName, categoryV.getUniqueId()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge); + } + return StorageOperationStatus.OK; + } + + @Override + public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { + JsonParseFlagEnum parseFlag = componentParametersView.detectParseFlag(); + + Either componentByLabelAndId = getComponentByLabelAndId(uniqueId, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, parseFlag); + if (componentByLabelAndId.isRight()) { + return Either.right(componentByLabelAndId.right().value()); + } + GraphVertex componentV = componentByLabelAndId.left().value(); + + return getToscaElement(componentV, componentParametersView); + + } + // ------------------------------------------------------------- + + public Either getToscaElement(GraphVertex componentV, ComponentParametersView componentParametersView) { + TopologyTemplate toscaElement; + + toscaElement = convertToTopologyTemplate(componentV); + JanusGraphOperationStatus status; + if (!componentParametersView.isIgnoreUsers()) { + status = setCreatorFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = setLastModifierFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreCategories()) { + status = setTopologyTempalteCategoriesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + if (!componentParametersView.isIgnoreArtifacts()) { + JanusGraphOperationStatus storageStatus = setAllArtifactsFromGraph(componentV, toscaElement); + if (storageStatus != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus)); + } + } + if (!componentParametersView.isIgnoreComponentInstancesProperties()) { + status = setComponentInstancesPropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreCapabilities()) { + status = setCapabilitiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreRequirements()) { + status = setRequirementsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreAllVersions()) { + status = setAllVersions(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!componentParametersView.isIgnoreAdditionalInformation()) { + status = setAdditionalInformationFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + if (!componentParametersView.isIgnoreGroups()) { + status = setGroupsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + } + if (!componentParametersView.isIgnorePolicies()) { + status = setPoliciesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + } + if (!componentParametersView.isIgnoreComponentInstances()) { + status = setInstGroupsFromGraph(componentV, toscaElement); + + //Mark all CIs that has archived origins + archiveOperation.setArchivedOriginsFlagInComponentInstances(componentV); + + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + } + if (!componentParametersView.isIgnoreInputs()) { + status = setInputsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + } + if (!componentParametersView.isIgnoreProperties()) { + status = setPropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + } + + if (!componentParametersView.isIgnoreComponentInstancesInputs()) { + status = setComponentInstancesInputsFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + + if (!componentParametersView.isIgnoreCapabiltyProperties()) { + status = setComponentInstancesCapPropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + + if (!componentParametersView.isIgnoreForwardingPath()) { + status = setForwardingGraphPropertiesFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + + if (!componentParametersView.isIgnoreNodeFilter()) { + status = setNodeFilterComponentFromGraph(componentV, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + + } + } + + if (!componentParametersView.isIgnoreInterfaces()) { + JanusGraphOperationStatus storageStatus = setInterfacesFromGraph(componentV, toscaElement); + if (storageStatus != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus)); + + } + } + + if (!componentParametersView.isIgnoreComponentInstancesInterfaces()) { + JanusGraphOperationStatus storageStatus = + setComponentInstancesInterfacesFromGraph(componentV, toscaElement); + if (storageStatus != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus)); + } + } + + if (!componentParametersView.isIgnoreDataType()) { + JanusGraphOperationStatus storageStatus = setDataTypesFromGraph(componentV, toscaElement); + if (storageStatus != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus)); + } + } + + return Either.left(toscaElement); + } + + private JanusGraphOperationStatus setDataTypesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.DATA_TYPES); + if (result.isLeft()) { + toscaElement.setDataTypes(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setPoliciesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.POLICIES); + if (result.isLeft()) { + toscaElement.setPolicies(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setInterfacesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE); + if (result.isLeft()) { + topologyTemplate.setInterfaces(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + + private JanusGraphOperationStatus setComponentInstancesInterfacesFromGraph(GraphVertex componentV, + TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = + getDataFromGraph(componentV, EdgeLabelEnum.INST_INTERFACES); + if (result.isLeft()) { + result.left().value().entrySet().forEach(entry -> topologyTemplate + .addComponentInstanceInterfaceMap(entry.getKey(), entry.getValue())); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private StorageOperationStatus associateInterfacesToComponent(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { + Map interfaceMap = topologyTemplate.getInterfaces(); + if (interfaceMap != null && !interfaceMap.isEmpty()) { + Either assosiateElementToData = associateElementToData(topologyTemplateVertex, VertexTypeEnum.INTERFACE, EdgeLabelEnum.INTERFACE, interfaceMap); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + public StorageOperationStatus associateNodeFiltersToComponent(GraphVertex nodeTypeVertex, + Map filterMaps) { + if (filterMaps != null && !filterMaps.isEmpty()) { + Either assosiateElementToData = associateElementToData + (nodeTypeVertex, VertexTypeEnum.NODE_FILTER_TEMPLATE, + EdgeLabelEnum.NODE_FILTER_TEMPLATE, filterMaps); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private JanusGraphOperationStatus setForwardingGraphPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.FORWARDING_PATH); + if (result.isLeft()) { + topologyTemplate.setForwardingPaths(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + + private JanusGraphOperationStatus setComponentInstancesCapPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); + if (result.isLeft()) { + topologyTemplate.setCalculatedCapabilitiesProperties(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + Either, JanusGraphOperationStatus> capPropResult = + getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES_PROPERTIES); + if (capPropResult.isLeft()) { + topologyTemplate.setCapabilitiesProperties(capPropResult.left().value()); + } else { + if (capPropResult.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return capPropResult.right().value(); + } + } + + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setPropertiesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.PROPERTIES); + if (result.isLeft()) { + toscaElement.setProperties(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setInstGroupsFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_GROUPS); + if (result.isLeft()) { + topologyTemplate.setInstGroups(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setComponentInstancesPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_PROPERTIES); + if (result.isLeft()) { + topologyTemplate.setInstProperties(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setComponentInstancesInputsFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_INPUTS); + if (result.isLeft()) { + topologyTemplate.setInstInputs(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setNodeFilterComponentFromGraph(GraphVertex componentV, + TopologyTemplate topologyTemplate) { + Either, JanusGraphOperationStatus> result = + getDataFromGraph(componentV, + EdgeLabelEnum.NODE_FILTER_TEMPLATE); + if (result.isLeft()) { + topologyTemplate.setNodeFilterComponents(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + @Override + protected JanusGraphOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (result.isLeft()) { + ((TopologyTemplate) toscaElement).setCalculatedRequirements(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + result = getDataFromGraph(componentV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (result.isLeft()) { + ((TopologyTemplate) toscaElement).setFullfilledRequirements(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + Either, JanusGraphOperationStatus> requirementResult = + getDataFromGraph(componentV, EdgeLabelEnum.REQUIREMENTS); + if (requirementResult.isLeft()) { + toscaElement.setRequirements(requirementResult.left().value()); + } else { + if (requirementResult.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return requirementResult.right().value(); + } + } + return JanusGraphOperationStatus.OK; + + } + + protected JanusGraphOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (result.isLeft()) { + ((TopologyTemplate) toscaElement).setCalculatedCapabilities(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + result = getDataFromGraph(componentV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (result.isLeft()) { + ((TopologyTemplate) toscaElement).setFullfilledCapabilities(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + Either, JanusGraphOperationStatus> capabilitiesResult = + getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES); + if (capabilitiesResult.isLeft()) { + toscaElement.setCapabilities(capabilitiesResult.left().value()); + } else { + if (capabilitiesResult.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return capabilitiesResult.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setAllArtifactsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + JanusGraphOperationStatus storageStatus = setArtifactsFromGraph(componentV, toscaElement); + if (storageStatus != JanusGraphOperationStatus.OK) { + return storageStatus; + } + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.SERVICE_API_ARTIFACTS); + if (result.isLeft()) { + toscaElement.setServiceApiArtifacts(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + Either, JanusGraphOperationStatus> resultInstArt = getDataFromGraph(componentV, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + if (resultInstArt.isLeft()) { + toscaElement.setInstDeploymentArtifacts(resultInstArt.left().value()); + } else { + if (resultInstArt.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return resultInstArt.right().value(); + } + } + Either, JanusGraphOperationStatus> instanceArt = getDataFromGraph(componentV, EdgeLabelEnum.INSTANCE_ARTIFACTS); + if (instanceArt.isLeft()) { + toscaElement.setInstanceArtifacts(instanceArt.left().value()); + } else { + if (instanceArt.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return instanceArt.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setInputsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INPUTS); + if (result.isLeft()) { + toscaElement.setInputs(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setGroupsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.GROUPS); + if (result.isLeft()) { + toscaElement.setGroups(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setTopologyTempalteCategoriesFromGraph(GraphVertex componentV, ToscaElement toscaElement) { + List categories = new ArrayList<>(); + + switch (componentV.getType()) { + case RESOURCE: + return setResourceCategoryFromGraph(componentV, toscaElement); + case SERVICE: + return setServiceCategoryFromGraph(componentV, toscaElement, categories); + + default: + log.debug("Not supported component type {} ", componentV.getType()); + break; + } + return JanusGraphOperationStatus.OK; + } + + private JanusGraphOperationStatus setServiceCategoryFromGraph(GraphVertex componentV, ToscaElement toscaElement, List categories) { + Either childVertex = janusGraphDao.getChildVertex(componentV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug("failed to fetch {} for tosca element with id {}, error {}", EdgeLabelEnum.CATEGORY, componentV.getUniqueId(), childVertex.right().value()); + return childVertex.right().value(); + } + GraphVertex categoryV = childVertex.left().value(); + Map metadataProperties = categoryV.getMetadataProperties(); + CategoryDefinition category = new CategoryDefinition(); + category.setUniqueId(categoryV.getUniqueId()); + category.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); + category.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); + + Type listTypeCat = new TypeToken>() { + }.getType(); + List iconsfromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS.getProperty()), listTypeCat); + category.setIcons(iconsfromJsonCat); + categories.add(category); + toscaElement.setCategories(categories); + + return JanusGraphOperationStatus.OK; + } + + @SuppressWarnings("unchecked") + private TopologyTemplate convertToTopologyTemplate(GraphVertex componentV) { + + TopologyTemplate topologyTemplate = super.convertToComponent(componentV); + + Map json = (Map) componentV.getJson(); + topologyTemplate.setCompositions(json); + + return topologyTemplate; + } + + @Override + public Either deleteToscaElement(GraphVertex toscaElementVertex) { + Either nodeType = getToscaElement(toscaElementVertex, new ComponentParametersView()); + if (nodeType.isRight()) { + log.debug("Failed to fetch tosca element {} error {}", toscaElementVertex.getUniqueId(), nodeType.right().value()); + return nodeType; + } + JanusGraphOperationStatus status = disassociateAndDeleteCommonElements(toscaElementVertex); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_ATTRIBUTES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instances attributes for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_PROPERTIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instances properties for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INPUTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instances inputs for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.GROUPS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate groups for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.POLICIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate policies for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_GROUPS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instance groups for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INPUTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate inputs for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INPUTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instance inputs for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES_PROPERTIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate capabilities properties for {} error {}", toscaElementVertex.getUniqueId(), status); + Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate calculated capabiliites for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FULLFILLED_CAPABILITIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate fullfilled capabilities for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate calculated capabiliites properties for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_REQUIREMENTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate calculated requirements for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate full filled requirements for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instance artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.SERVICE_API_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate service api artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FORWARDING_PATH); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate service api artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INTERFACE); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate interfaces for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INSTANCE_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instance artifact for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, + EdgeLabelEnum.REQUIREMENTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate requirements for {} error {}", + toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, + EdgeLabelEnum.CAPABILITIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate capabilities for {} error {}", + toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INTERFACES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disassociate instances interfaces for {} error {}", toscaElementVertex.getUniqueId(), status); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + toscaElementVertex.getVertex().remove(); + log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId()); + + return nodeType; + } + + @SuppressWarnings("unchecked") + @Override + public Either createToscaElement(ToscaElement toscaElement) { + return createTopologyTemplate((TopologyTemplate) toscaElement); + } + + @Override + protected JanusGraphOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { + return setTopologyTempalteCategoriesFromGraph(vertexComponent, toscaElement); + } + + @Override + protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { + // Product isn't supported now!! + // TODO add for Product + if (toscaElementToUpdate.getComponentType() == ComponentTypeEnum.SERVICE) { + return validateServiceCategory(toscaElementToUpdate, elementV); + } else { + // Resource + return validateResourceCategory(toscaElementToUpdate, elementV); + } + } + + @Override + protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex updateElementV) { + // not relevant now for topology template + return StorageOperationStatus.OK; + } + + @Override + public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { + fillMetadata(elementV, (TopologyTemplate) toscaElementToUpdate, flag); + } + + private StorageOperationStatus validateServiceCategory(T toscaElementToUpdate, GraphVertex elementV) { + StorageOperationStatus status = StorageOperationStatus.OK; + List newCategoryList = toscaElementToUpdate.getCategories(); + CategoryDefinition newCategory = newCategoryList.get(0); + + Either childVertex = janusGraphDao.getChildVertex(elementV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug("failed to fetch {} for tosca element with id {}, error {}", EdgeLabelEnum.CATEGORY, elementV.getUniqueId(), childVertex.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childVertex.right().value()); + } + + GraphVertex categoryV = childVertex.left().value(); + Map metadataProperties = categoryV.getMetadataProperties(); + String categoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); + + String newCategoryName = newCategory.getName(); + if (newCategoryName != null && !newCategoryName.equals(categoryNameCurrent)) { + // the category was changed + Either getCategoryVertex = categoryOperation.getCategory(newCategoryName, VertexTypeEnum.SERVICE_CATEGORY); + + if (getCategoryVertex.isRight()) { + return getCategoryVertex.right().value(); + } + GraphVertex newCategoryV = getCategoryVertex.left().value(); + status = moveCategoryEdge(elementV, newCategoryV); + log.debug("Going to update the category of the resource from {} to {}. status is {}", categoryNameCurrent, newCategory, status); + } + return status; + } + + public Either updateDistributionStatus(String uniqueId, User user, DistributionStatusEnum distributionStatus) { + + Either result = null; + String userId = user.getUserId(); + Either getRes = findUserVertex(userId); + GraphVertex userVertex = null; + GraphVertex serviceVertex = null; + if (getRes.isRight()) { + JanusGraphOperationStatus status = getRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Cannot find user {} in the graph. status is {}", userId, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + userVertex = getRes.left().value(); + getRes = janusGraphDao.getVertexById(uniqueId, JsonParseFlagEnum.ParseMetadata); + if (getRes.isRight()) { + JanusGraphOperationStatus status = getRes.right().value(); + log.debug("Cannot find service {} in the graph. status is {}", uniqueId, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + serviceVertex = getRes.left().value(); + Iterator edgeIterator = serviceVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER.name()); + if (edgeIterator.hasNext()) { + log.debug("Remove existing edge from user to component {}. Edge type is {}", userId, uniqueId, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER); + edgeIterator.next().remove(); + } + } + if (result == null) { + JanusGraphOperationStatus status = janusGraphDao.createEdge(userVertex, serviceVertex, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER, null); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to associate user {} to component {}. Edge type is {}", userId, uniqueId, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + serviceVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, distributionStatus.name()); + long lastUpdateDate = System.currentTimeMillis(); + serviceVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, lastUpdateDate); + Either updateRes = janusGraphDao.updateVertex(serviceVertex); + if (updateRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateRes.right().value())); + } + } + if (result == null) { + result = Either.left(serviceVertex); + } + return result; + } + + /** + * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId + * + * @param componentId + * @param instanceId + * @param capabilityName + * @param capabilityType + * @param ownerId + * @return + */ + public Either, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityName, String capabilityType, String ownerId) { + + Either, StorageOperationStatus> result = null; + Map mapPropertiesDataDefinition = null; + Either componentByLabelAndId = getComponentByLabelAndId(componentId, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.NoParse); + if (componentByLabelAndId.isRight()) { + result = Either.right(componentByLabelAndId.right().value()); + } + if (componentByLabelAndId.isLeft()) { + Either, JanusGraphOperationStatus> getDataRes = getDataFromGraph(componentByLabelAndId.left().value(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); + if (getDataRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getDataRes.right().value())); + } else { + mapPropertiesDataDefinition = getDataRes.left().value(); + } + } + if (isNotEmptyMapOfProperties(instanceId, mapPropertiesDataDefinition)) { + result = Either.left(findComponentInstanceCapabilityProperties(instanceId, capabilityName, capabilityType, ownerId, mapPropertiesDataDefinition.get(instanceId).getMapToscaDataDefinition())); + } + return result; + } + + public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceId, MapCapabilityProperty instanceProperties) { + return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instanceProperties, componentInstanceId); + } + + public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, + String componentInstanceId, + MapInterfaceDataDefinition instanceInterfaces) { + if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) { + return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), + EdgeLabelEnum.INST_INTERFACES, instanceInterfaces, componentInstanceId); + } + return StorageOperationStatus.OK; + } + + + private boolean isNotEmptyMapOfProperties(String instanceId, Map mapPropertiesDataDefinition) { + return MapUtils.isNotEmpty(mapPropertiesDataDefinition) && + mapPropertiesDataDefinition.get(instanceId) != null && + MapUtils.isNotEmpty(mapPropertiesDataDefinition.get(instanceId).getMapToscaDataDefinition()); + } + + private List findComponentInstanceCapabilityProperties(String instanceId, String capabilityName, String capabilityType, String ownerId, Map propertiesMap) { + List capPropsList = null; + for (Entry capProp : propertiesMap.entrySet()) { + if (isBelongingPropertyMap(instanceId, capabilityName, capabilityType, ownerId, capProp)) { + Map capMap = capProp.getValue().getMapToscaDataDefinition(); + if (capMap != null && !capMap.isEmpty()) { + capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()); + break; + } + } + } + if (capPropsList == null) { + capPropsList = new ArrayList<>(); + } + return capPropsList; + } + + private boolean isBelongingPropertyMap(String instanceId, String capabilityName, String capabilityType, String ownerId, Entry capProp) { + if (capProp != null) { + String[] path = capProp.getKey().split(ModelConverter.CAP_PROP_DELIM); + if (path.length < 4) { + log.debug("wrong key format for capabilty, key {}", capProp); + return false; + } + return path[path.length - 2].equals(capabilityType) && path[path.length - 1].equals(capabilityName) && path[1].equals(ownerId) && path[0].equals(instanceId); + } + return false; + } + + public StorageOperationStatus addPolicyToToscaElement(GraphVertex componentV, PolicyDefinition policyDefinition, int counter) { + fillPolicyDefinition(componentV, policyDefinition, counter); + return addToscaDataToToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyDefinition, JsonPresentationFields.UNIQUE_ID); + } + + public StorageOperationStatus addPoliciesToToscaElement(GraphVertex componentV, List policies) { + return addToscaDataToToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policies, JsonPresentationFields.UNIQUE_ID); + } + + public StorageOperationStatus updatePolicyOfToscaElement(GraphVertex componentV, PolicyDefinition policyDefinition) { + return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyDefinition, JsonPresentationFields.UNIQUE_ID); + } + + public StorageOperationStatus updatePoliciesOfToscaElement(GraphVertex componentV, List policiesDefinitions) { + return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policiesDefinitions, JsonPresentationFields.UNIQUE_ID); + } + + public StorageOperationStatus removePolicyFromToscaElement(GraphVertex componentV, String policyId) { + return deleteToscaDataElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyId, JsonPresentationFields.UNIQUE_ID); + } + + public StorageOperationStatus updateGroupOfToscaElement(GraphVertex componentV, GroupDefinition groupDefinition) { + return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groupDefinition, JsonPresentationFields.NAME); + } + + private void fillPolicyDefinition(GraphVertex componentV, PolicyDefinition policyDefinition, int counter) { + String policyName = buildSubComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME), policyDefinition.getPolicyTypeName(), counter); + policyDefinition.setName(policyName); + policyDefinition.setInvariantName(policyName); + policyDefinition.setComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME)); + policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(componentV.getUniqueId(), policyName)); + policyDefinition.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID()); + policyDefinition.setPolicyUUID(UniqueIdBuilder.generateUUID()); + } + + public static String buildSubComponentName(String componentName, String subComponentTypeName, int counter) { + String normalizedComponentName = ValidationUtils.normalizeComponentInstanceName(componentName); + String typeSuffix = subComponentTypeName.substring(subComponentTypeName.lastIndexOf('.') + 1, subComponentTypeName.length()); + return normalizedComponentName + Constants.GROUP_POLICY_NAME_DELIMETER + typeSuffix + Constants.GROUP_POLICY_NAME_DELIMETER + counter; + } + + void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) { + if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) { + GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) + .left() + .on(this::throwStorageException); + if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) { + toscaElement.getComponentInstances().values().forEach(i -> CapabilityRequirementNameResolver.revertNamesOfCalculatedCapabilitiesRequirements(toscaElement, i.getUniqueId(), this::getOriginToscaElement)); + } + if (MapUtils.isNotEmpty(toscaElement.getGroups())) { + toscaElement.getGroups().values().forEach(g -> CapabilityRequirementNameResolver.revertNamesOfCalculatedCapabilitiesRequirements(toscaElement, g.getUniqueId(), this::getOriginToscaElement)); + } + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, toscaElement.getCalculatedCapabilities()); + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, toscaElement.getCalculatedRequirements()); + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, toscaElement.getCalculatedCapabilitiesProperties()); + } + } + + public void updateNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) { + if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) { + GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) + .left() + .on(this::throwStorageException); + if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) { + toscaElement.getComponentInstances().values().forEach(i -> CapabilityRequirementNameResolver.updateNamesOfCalculatedCapabilitiesRequirements(toscaElement, i.getUniqueId(), i.getNormalizedName(), this::getOriginToscaElement)); + } + if (MapUtils.isNotEmpty(toscaElement.getGroups())) { + toscaElement.getGroups().values().forEach(g -> CapabilityRequirementNameResolver.updateNamesOfCalculatedCapabilitiesRequirements(toscaElement, g.getUniqueId(), g.getName(), this::getOriginToscaElement)); + } + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, toscaElement.getCalculatedCapabilities()); + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, toscaElement.getCalculatedRequirements()); + topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, toscaElement.getCalculatedCapabilitiesProperties()); + } + } + + private ToscaElement getOriginToscaElement(ComponentInstanceDataDefinition instance) { + log.debug("#getOriginToscaElement - origin name: {}", instance.getComponentName()); + ToscaElementTypeEnum elementType = detectToscaType(instance.getOriginType()); + Either getOriginRes; + if (elementType == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE) { + getOriginRes = this.getToscaElement(CapabilityRequirementNameResolver.getActualComponentUid(instance), getFilter()); + + } else { + getOriginRes = nodeTypeOperation.getToscaElement(CapabilityRequirementNameResolver.getActualComponentUid(instance), getFilter()); + } + if (getOriginRes.isRight()) { + log.debug("Failed to get an origin component with uniqueId {}", CapabilityRequirementNameResolver.getActualComponentUid(instance)); + throw new StorageException(getOriginRes.right().value()); + } + return getOriginRes.left().value(); + } + + private ToscaElementTypeEnum detectToscaType(OriginTypeEnum originType) { + log.debug("#detectToscaType - type: {}", originType); + if (nodeTypeSet.contains(originType)){ + return ToscaElementTypeEnum.NODE_TYPE; + } else { + return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE; + } + } + + private ComponentParametersView getFilter() { + ComponentParametersView filter = new ComponentParametersView(); + filter.setIgnoreCapabilities(false); + filter.setIgnoreCapabiltyProperties(false); + filter.setIgnoreRequirements(false); + return filter; + } + public void updateCapReqPropertiesOwnerId(String componentId, TopologyTemplate toscaElement) { + GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) + .left().on(this::throwStorageException); + updateCapOwnerId(toscaElement, componentId); + updateReqOwnerId(toscaElement, componentId); + updatePropertiesOwnerId(toscaElement, componentId); + topologyTemplateOperation + + .updateFullToscaData(toscaElementV, EdgeLabelEnum.CAPABILITIES, + VertexTypeEnum.CAPABILITIES, toscaElement.getCapabilities()); + topologyTemplateOperation + .updateFullToscaData(toscaElementV, EdgeLabelEnum.REQUIREMENTS, + VertexTypeEnum.REQUIREMENTS, toscaElement.getRequirements()); + topologyTemplateOperation + .updateFullToscaData(toscaElementV, EdgeLabelEnum.PROPERTIES, + VertexTypeEnum.PROPERTIES, toscaElement.getProperties()); + } + + private void updateCapOwnerId(ToscaElement toscaElement, String ownerId) { + if(MapUtils.isNotEmpty(toscaElement.getCapabilities())) { + toscaElement.getCapabilities().values().stream().flatMap(listCapDef -> listCapDef.getListToscaDataDefinition().stream()) + .forEach(capabilityDefinition -> capabilityDefinition.setOwnerId(ownerId)); + } + } + + private void updateReqOwnerId(ToscaElement toscaElement, String ownerId) { + if(MapUtils.isNotEmpty(toscaElement.getRequirements())) { + toscaElement.getRequirements().values().stream().flatMap(listReqDef -> listReqDef.getListToscaDataDefinition().stream()) + .forEach(requirementDefinition -> requirementDefinition.setOwnerId(ownerId)); + } + } + + private void updatePropertiesOwnerId(ToscaElement toscaElement, String ownerId) { + Map properties = toscaElement.getProperties(); + if(MapUtils.isNotEmpty(properties)) { + properties.values().forEach(propertyDataDefinition -> propertyDataDefinition.setParentUniqueId(ownerId)); + } + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaDataOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaDataOperation.java new file mode 100644 index 0000000000..1501b79ca5 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaDataOperation.java @@ -0,0 +1,25 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +@org.springframework.stereotype.Component("tosca-data-operation") +public class ToscaDataOperation extends BaseOperation { +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementLifecycleOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementLifecycleOperation.java new file mode 100644 index 0000000000..771620d758 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementLifecycleOperation.java @@ -0,0 +1,1636 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; +import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.DistributionStatusEnum; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; + +import java.util.*; +import java.util.stream.Collectors; + +@org.springframework.stereotype.Component("tosca-element-lifecycle-operation") + +/** + * Allows to perform lifecycle operations: checkin, checkout, submit for testing, start certification and certification process for tosca element + */ +public class ToscaElementLifecycleOperation extends BaseOperation { + + private static final String FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS = "Failed to delete last state edge. Status is {}. "; + private static final String FAILED_TO_GET_VERTICES = "Failed to get vertices by id {}. Status is {}. "; + public static final String VERSION_DELIMITER = "."; + public static final String VERSION_DELIMITER_REGEXP = "\\."; + + private static final Logger log = Logger.getLogger(ToscaElementLifecycleOperation.class); + + /** + * Performs changing a lifecycle state of tosca element from "checked out" or "ready for certification" to "checked in" + * + * @param currState + * @param toscaElementId + * @param modifierId + * @param ownerId + * @return + */ + public Either checkinToscaELement(LifecycleStateEnum currState, String toscaElementId, String modifierId, String ownerId) { + Either updateResult = null; + Either result = null; + Map vertices = null; + ToscaElementOperation operation; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckin(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + updateResult = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } else { + vertices = getVerticesRes.left().value(); + updateResult = checkinToscaELement(currState, vertices.get(toscaElementId), vertices.get(ownerId), vertices.get(modifierId), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + } + if (updateResult.isLeft()) { + operation = getToscaElementOperation(vertices.get(toscaElementId).getLabel()); + result = operation.getToscaElement(updateResult.left().value().getUniqueId()); + if (result.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated tosca element {}. Status is {}", toscaElementId, result.right().value()); + } + } else { + result = Either.right(updateResult.right().value()); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during checkin of tosca element {}. {} ", toscaElementId, e.getMessage()); + } + return result; + } + + /** + * Returns vertex presenting owner of tosca element specified by uniqueId + * + * @param toscaElementId + * @return + */ + public Either getToscaElementOwner(String toscaElementId) { + Either result = null; + GraphVertex toscaElement = null; + Either getToscaElementRes = janusGraphDao + .getVertexById(toscaElementId, JsonParseFlagEnum.NoParse); + if (getToscaElementRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value())); + } + if (result == null) { + toscaElement = getToscaElementRes.left().value(); + Iterator vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name()); + if (vertices == null || !vertices.hasNext()) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } else { + result = Either.left(convertToUser(vertices.next())); + } + } + return result; + } + + /** + * Returns vertex presenting owner of tosca element specified by uniqueId + * + * @param toscaElement + * @return + */ + public Either getToscaElementOwner(GraphVertex toscaElement) { + Either result = null; + Iterator vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name()); + if (vertices == null || !vertices.hasNext()) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } else { + result = Either.left(convertToUser(vertices.next())); + } + return result; + } + + /** + * Performs checkout of a tosca element + * + * @param toscaElementId + * @param modifierId + * @param ownerId + * @return + */ + public Either checkoutToscaElement(String toscaElementId, String modifierId, String ownerId) { + Either result = null; + Map vertices = null; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckout(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + vertices = getVerticesRes.left().value(); + // update previous component if not certified + StorageOperationStatus status = updatePreviousVersion(vertices.get(toscaElementId), vertices.get(ownerId)); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update vertex with id {} . Status is {}. ", status); + result = Either.right(status); + } + } + if (result == null) { + result = cloneToscaElementForCheckout(vertices.get(toscaElementId), vertices.get(modifierId)); + if (result.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to checkout tosca element {}. Status is {} ", toscaElementId, result.right().value()); + } + + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during checkout tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + /** + * Performs undo checkout for tosca element + * + * @param toscaElementId + * @return + */ + public Either undoCheckout(String toscaElementId) { + Either result = null; + Either getToscaElementRes = null; + Iterator nextVersionComponentIter = null; + ToscaElementOperation operation; + Vertex preVersionVertex = null; + try { + getToscaElementRes = janusGraphDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata); + if (getToscaElementRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value())); + } + GraphVertex currVersionV = getToscaElementRes.left().value(); + if (result == null && hasPreviousVersion(currVersionV)) { + // find previous version + nextVersionComponentIter = currVersionV.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name()); + if (nextVersionComponentIter == null || !nextVersionComponentIter.hasNext()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch previous version of tosca element with name {}. ", currVersionV.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString()); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + if (result == null) { + preVersionVertex = nextVersionComponentIter.next().outVertex(); + StorageOperationStatus updateOldResourceResult = updateOldToscaElementBeforeUndoCheckout(preVersionVertex); + if (updateOldResourceResult != StorageOperationStatus.OK) { + result = Either.right(updateOldResourceResult); + } + } + } + if (result == null) { + StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRootByUndoCheckout((JanusGraphVertex) preVersionVertex, currVersionV); + if (updateCatalogRes != StorageOperationStatus.OK) { + return Either.right(updateCatalogRes); + } + operation = getToscaElementOperation(currVersionV.getLabel()); + result = operation.deleteToscaElement(currVersionV); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during undo checkout tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + private boolean hasPreviousVersion(GraphVertex toscaElementVertex) { + boolean hasPreviousVersion = true; + String version = (String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION); + if (StringUtils.isEmpty(version) || "0.1".equals(version)) + hasPreviousVersion = false; + return hasPreviousVersion; + } + + /** + * Performs request certification for tosca element + * + * @param toscaElementId + * @param modifierId + * @param ownerId + * @return + */ + public Either requestCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) { + Either resultUpdate = null; + Either result = null; + GraphVertex toscaElement = null; + GraphVertex modifier = null; + GraphVertex owner; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + toscaElement = getVerticesRes.left().value().get(toscaElementId); + modifier = getVerticesRes.left().value().get(modifierId); + owner = getVerticesRes.left().value().get(ownerId); + + StorageOperationStatus status = handleRelationsUponRequestForCertification(toscaElement, modifier, owner); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations on certification request for tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + LifecycleStateEnum nextState = LifecycleStateEnum.READY_FOR_CERTIFICATION; + + toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); + toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + + resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); + if (resultUpdate.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set lifecycle for tosca elememt {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); + result = Either.right(resultUpdate.right().value()); + } + } + if (result == null) { + ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); + result = operation.getToscaElement(toscaElement.getUniqueId()); + } + return result; + + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during request certification tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + /** + * Starts certification of tosca element + * + * @param toscaElementId + * @param modifierId + * @param ownerId + * @return + */ + public Either startCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) { + Either result = null; + Either resultUpdate = null; + GraphVertex toscaElement = null; + GraphVertex modifier = null; + GraphVertex owner; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + toscaElement = getVerticesRes.left().value().get(toscaElementId); + modifier = getVerticesRes.left().value().get(modifierId); + owner = getVerticesRes.left().value().get(ownerId); + + StorageOperationStatus status = handleRelationsUponCertification(toscaElement, modifier, owner); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations during certification of tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + LifecycleStateEnum nextState = LifecycleStateEnum.CERTIFICATION_IN_PROGRESS; + + toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); + toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + + resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); + if (resultUpdate.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Couldn't set lifecycle for component {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); + result = Either.right(resultUpdate.right().value()); + } + } + if (result == null) { + ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); + result = operation.getToscaElement(toscaElement.getUniqueId()); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during start certification tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + public Either certifyToscaElement(String toscaElementId, String modifierId, String ownerId) { + Either result = null; + Either cloneRes = null; + GraphVertex toscaElement = null; + GraphVertex modifier = null; + GraphVertex certifiedToscaElement = null; + Integer majorVersion = null; + + StorageOperationStatus status; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + toscaElement = getVerticesRes.left().value().get(toscaElementId); + modifier = getVerticesRes.left().value().get(modifierId); + majorVersion = getMajorVersion((String) toscaElement.getMetadataProperty(GraphPropertyEnum.VERSION)); + status = handleRelationsOfPreviousToscaElementBeforeCertifying(toscaElement, modifier, majorVersion); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations of previous tosca element before certifying {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + cloneRes = cloneToscaElementForCertify(toscaElement, modifier, majorVersion); + if (cloneRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element during certification. "); + result = Either.right(cloneRes.right().value()); + } + } + if (result == null) { + certifiedToscaElement = cloneRes.left().value(); + status = handleRelationsOfNewestCertifiedToscaElement(toscaElement, certifiedToscaElement); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations of newest certified tosca element {}. Status is {}. ", certifiedToscaElement.getUniqueId(), status); + } + } + if (result == null) { + return getToscaElementOperation(toscaElement.getLabel()).getToscaElement(certifiedToscaElement.getUniqueId()); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during certification tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + /** + * Deletes (marks as deleted) all tosca elements according received name and uuid + * + * @param vertexType + * @param componentType + * @param componentName + * @param uuid + * @return + */ + public Either deleteOldToscaElementVersions(VertexTypeEnum vertexType, ComponentTypeEnum componentType, String componentName, String uuid) { + + Either result = null; + ToscaElementOperation operation = getToscaElementOperation(componentType); + + try { + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.UUID, uuid); + properties.put(GraphPropertyEnum.NAME, componentName); + Either, JanusGraphOperationStatus> getToscaElementsRes = janusGraphDao + .getByCriteria(vertexType, properties, JsonParseFlagEnum.ParseMetadata); + if (getToscaElementsRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementsRes.right().value())); + } + if (result == null) { + result = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value()); + } + if (result == null) { + result = Either.left(true); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage()); + } + return result; + } + + /** + * Performs cancelation or failure of certification for received tosca element + * + * @param toscaElementId + * @param modifierId + * @param ownerId + * @param nextState + * @return + */ + public Either cancelOrFailCertification(String toscaElementId, String modifierId, String ownerId, LifecycleStateEnum nextState) { + Either result = null; + StorageOperationStatus status; + ToscaElementOperation operation = null; + GraphVertex toscaElement = null; + GraphVertex modifier = null; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + toscaElement = getVerticesRes.left().value().get(toscaElementId); + modifier = getVerticesRes.left().value().get(modifierId); + operation = getToscaElementOperation(toscaElement.getLabel()); + toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + toscaElement.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifier.getUniqueId()); + toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); + + Either updateVertexRes = janusGraphDao.updateVertex(toscaElement); + if (updateVertexRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update vertex {} . Status is {}. ", toscaElementId, updateVertexRes.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateVertexRes.right().value())); + } + } + if (result == null) { + // cancel certification process + status = handleRelationsUponCancelCertification(toscaElement, nextState); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations upon cancel certification {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + // fail certification + status = handleRelationsUponFailCertification(toscaElement, nextState); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations upon fail certification {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + result = operation.getToscaElement(toscaElementId); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during cancel or fail certification of tosca element {}. {}. ", toscaElementId, e.getMessage()); + } + return result; + } + + public Either findUser(String userId) { + return findUserVertex(userId); + } + + private Either markToscaElementsAsDeleted(ToscaElementOperation operation, List toscaElements) { + Either result = Either.left(true); + for (GraphVertex resourceToDelete : toscaElements) { + if (!((String) resourceToDelete.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals(LifecycleStateEnum.CERTIFIED.name())) { + Either deleteElementRes = operation.markComponentToDelete(resourceToDelete); + if (deleteElementRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca element {}. Status is {}. ", resourceToDelete.getUniqueId(), deleteElementRes.right().value()); + result = Either.right(deleteElementRes.right().value()); + break; + } + } + } + return result; + } + + private StorageOperationStatus handleRelationsOfNewestCertifiedToscaElement(GraphVertex toscaElement, GraphVertex certifiedToscaElement) { + StorageOperationStatus result = null; + Edge foundEdge = null; + Iterator certReqUserEdgeIter = null; + // add rfc relation to preserve follower information + // get user of certification request + certReqUserEdgeIter = toscaElement.getVertex().edges(Direction.IN, GraphEdgeLabels.LAST_STATE.name()); + if (certReqUserEdgeIter == null || !certReqUserEdgeIter.hasNext()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. "); + result = StorageOperationStatus.NOT_FOUND; + } + if (result == null) { + JanusGraphOperationStatus + createVersionEdgeStatus = janusGraphDao + .createEdge(toscaElement, certifiedToscaElement, EdgeLabelEnum.VERSION, new HashMap<>()); + if (createVersionEdgeStatus != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create version edge from last element {} to new certified element {}. status=", toscaElement.getUniqueId(), certifiedToscaElement.getUniqueId(), + createVersionEdgeStatus); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createVersionEdgeStatus); + } + } + if (result == null) { + if (certReqUserEdgeIter!=null) { + while (certReqUserEdgeIter.hasNext()) { + Edge edge = certReqUserEdgeIter.next(); + if (((String) janusGraphDao.getProperty(edge, EdgePropertyEnum.STATE)).equals(LifecycleStateEnum.READY_FOR_CERTIFICATION.name())) { + foundEdge = edge; + break; + } + + } + } + if (foundEdge == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. "); + result = StorageOperationStatus.NOT_FOUND; + } + } + if (result == null) { + JanusGraphOperationStatus + createEdgeRes = janusGraphDao + .createEdge(foundEdge.outVertex(), certifiedToscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, foundEdge); + if (createEdgeRes != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create rfc relation for component {}. status=", certifiedToscaElement.getUniqueId(), createEdgeRes); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus handleRelationsUponFailCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) { + StorageOperationStatus result = null; + JanusGraphOperationStatus status = null; + Edge originEdge; + Vertex user = null; + if (nextState == LifecycleStateEnum.NOT_CERTIFIED_CHECKIN) { + // fail certification + // delete relation CERTIFICATION_IN_PROGRESS + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); + + Either deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties); + if (deleteResult.isRight()) { + status = deleteResult.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", status); + result = StorageOperationStatus.INCONSISTENCY; + } + if (result == null) { + // delete relation READY_FOR_CERTIFICATION + properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION); + deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); + if (deleteResult.isRight()) { + status = deleteResult.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + // delete relation NOT_CERTIFIED_CHECKIN (in order to change to STATE) + properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); + if (deleteResult.isRight()) { + status = deleteResult.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + // create new STATE relation NOT_CERTIFIED_CHECKIN + originEdge = deleteResult.left().value(); + user = originEdge.outVertex(); + status = janusGraphDao + .createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + // delete relation LAST_MODIFIER (in order to change tester to designer) + deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + // create new LAST_MODIFIER relation + originEdge = deleteResult.left().value(); + status = janusGraphDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.LAST_MODIFIER, originEdge); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus handleRelationsUponCancelCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) { + StorageOperationStatus result = null; + Edge originEdge; + if (nextState == LifecycleStateEnum.READY_FOR_CERTIFICATION) { + // delete relation CERTIFICATION_IN_PROGRESS + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); + Either deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties); + + if (deleteResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", deleteResult.right().value()); + result = StorageOperationStatus.INCONSISTENCY; + } + if (result == null) { + // delete relation READY_FOR_CERTIFICATION (LAST_STATE) + properties.put(GraphPropertyEnum.STATE, nextState); + deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); + + if (deleteResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, deleteResult.right().value()); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + // create relation READY_FOR_CERTIFICATION (STATE) + originEdge = deleteResult.left().value(); + JanusGraphOperationStatus + status = janusGraphDao + .createEdge(originEdge.outVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status); + result = StorageOperationStatus.INCONSISTENCY; + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + } + return result; + } + + private StorageOperationStatus handleRelationsOfPreviousToscaElementBeforeCertifying(GraphVertex toscaElement, GraphVertex modifier, Integer majorVersion) { + StorageOperationStatus result = null; + if (majorVersion > 0) { + Either findRes = findLastCertifiedToscaElementVertex(toscaElement); + if (findRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch last certified tosca element {} . Status is {}. ", toscaElement.getMetadataProperty(GraphPropertyEnum.NAME), findRes.right().value()); + result = findRes.right().value(); + } + if (result == null) { + Vertex lastCertifiedVertex = findRes.left().value(); + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false); + JanusGraphOperationStatus status = janusGraphDao + .updateVertexMetadataPropertiesWithJson(lastCertifiedVertex, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of tosca element {} to [{}]. Status is {}", toscaElement.getUniqueId(), false, status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + // remove previous certified version from the catalog + GraphVertex lastCertifiedV = new GraphVertex(); + lastCertifiedV.setVertex((JanusGraphVertex) lastCertifiedVertex); + lastCertifiedV.setUniqueId((String) janusGraphDao + .getProperty((JanusGraphVertex) lastCertifiedVertex, GraphPropertyEnum.UNIQUE_ID.getProperty())); + StorageOperationStatus res = updateEdgeToCatalogRoot(null, lastCertifiedV); + if (res != StorageOperationStatus.OK) { + return res; + } + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus handleRelationsUponRequestForCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { + JanusGraphOperationStatus status; + StorageOperationStatus result = null; + + if (((String) toscaElement.getMetadataProperty(GraphPropertyEnum.STATE)).equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { + // remove CHECKOUT relation + Either deleteRes = janusGraphDao + .deleteEdge(owner, toscaElement, EdgeLabelEnum.STATE); + if (deleteRes.isRight()) { + status = deleteRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge. Status is {}. ", status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (result == null) { + // create CHECKIN relation + Map properties = new EnumMap<>(EdgePropertyEnum.class); + properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + status = janusGraphDao + .createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + } else { + status = janusGraphDao + .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); + if (status != JanusGraphOperationStatus.OK) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + if (result == null) { + // create RFC relation + Map properties = new EnumMap<>(EdgePropertyEnum.class); + properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION); + status = janusGraphDao + .createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus handleRelationsUponCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { + + StorageOperationStatus result = null; + JanusGraphOperationStatus status = janusGraphDao + .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); + if (status != JanusGraphOperationStatus.OK) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (result == null) { + Map properties = new EnumMap<>(EdgePropertyEnum.class); + properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); + status = janusGraphDao + .createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + if (result == null) { + Either updateRelationsRes = updateLastModifierEdge(toscaElement, owner, modifier); + if (updateRelationsRes.isRight()) { + result = updateRelationsRes.right().value(); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private Either findLastCertifiedToscaElementVertex(GraphVertex toscaElement) { + return findLastCertifiedToscaElementVertexRecursively(toscaElement.getVertex()); + } + + private Either findLastCertifiedToscaElementVertexRecursively(Vertex vertex) { + if (isCertifiedVersion((String) vertex.property(GraphPropertyEnum.VERSION.getProperty()).value())) { + return Either.left(vertex); + } + Iterator edgeIter = vertex.edges(Direction.IN, EdgeLabelEnum.VERSION.name()); + if (!edgeIter.hasNext()) { + return Either.right(StorageOperationStatus.NOT_FOUND); + } + return findLastCertifiedToscaElementVertexRecursively(edgeIter.next().outVertex()); + } + + private boolean isCertifiedVersion(String version) { + String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); + if (Integer.parseInt(versionParts[0]) > 0 && Integer.parseInt(versionParts[1]) == 0) { + return true; + } + return false; + } + + private StorageOperationStatus updateOldToscaElementBeforeUndoCheckout(Vertex previousVersionToscaElement) { + + StorageOperationStatus result = StorageOperationStatus.OK; + String previousVersion = (String) previousVersionToscaElement.property(GraphPropertyEnum.VERSION.getProperty()).value(); + if (!previousVersion.endsWith(".0")) { + try { + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update vertex of previous version of tosca element", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty())); + + Map propertiesToUpdate = new HashMap<>(); + propertiesToUpdate.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true); + Map jsonMetadataMap = JsonParserUtils.toMap((String) previousVersionToscaElement.property(GraphPropertyEnum.METADATA.getProperty()).value()); + jsonMetadataMap.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true); + propertiesToUpdate.put(GraphPropertyEnum.METADATA.getProperty(), JsonParserUtils.toJson(jsonMetadataMap)); + + janusGraphDao.setVertexProperties(previousVersionToscaElement, propertiesToUpdate); + + Iterator edgesIter = previousVersionToscaElement.edges(Direction.IN, EdgeLabelEnum.LAST_STATE.name()); + if (!edgesIter.hasNext()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch last modifier vertex for tosca element {}. ", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty())); + result = StorageOperationStatus.NOT_FOUND; + } else { + Edge lastStateEdge = edgesIter.next(); + Vertex lastModifier = lastStateEdge.outVertex(); + JanusGraphOperationStatus replaceRes = janusGraphDao + .replaceEdgeLabel(lastModifier, previousVersionToscaElement, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE); + if (replaceRes != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to replace label from {} to {}. status = {}", EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE, replaceRes); + result = StorageOperationStatus.INCONSISTENCY; + if (replaceRes != JanusGraphOperationStatus.INVALID_ID) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(replaceRes); + } + } + + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during update previous tosca element {} before undo checkout. {} ", e.getMessage()); + } + } + return result; + } + + private StorageOperationStatus updatePreviousVersion(GraphVertex toscaElementVertex, GraphVertex ownerVertex) { + StorageOperationStatus result = null; + String ownerId = (String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID); + String toscaElementId = toscaElementVertex.getUniqueId(); + if (!toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) { + toscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false); + Either updateVertexRes = janusGraphDao.updateVertex(toscaElementVertex); + if (updateVertexRes.isRight()) { + JanusGraphOperationStatus titatStatus = updateVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update tosca element vertex {}. Status is {}", toscaElementVertex.getUniqueId(), titatStatus); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus); + } + Either deleteEdgeRes = null; + if (result == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to replace edge with label {} to label {} from {} to {}. ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId); + + deleteEdgeRes = janusGraphDao + .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE); + if (deleteEdgeRes.isRight()) { + JanusGraphOperationStatus janusGraphStatus = deleteEdgeRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge with label {} from {} to {}. Status is {} ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId, janusGraphStatus); + if (!janusGraphStatus.equals(JanusGraphOperationStatus.INVALID_ID)) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphStatus); + } else { + result = StorageOperationStatus.INCONSISTENCY; + } + } + } + if (result == null) { + JanusGraphOperationStatus + createEdgeRes = janusGraphDao + .createEdge(ownerVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_STATE, deleteEdgeRes.left().value()); + if (createEdgeRes != JanusGraphOperationStatus.OK) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes); + } + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private Either cloneToscaElementForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) { + + Either result = null; + Either cloneResult = null; + ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel()); + // check if component with the next version doesn't exist. + Iterator nextVersionComponentIter = toscaElementVertex.getVertex().edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); + if (nextVersionComponentIter != null && nextVersionComponentIter.hasNext()) { + Vertex nextVersionVertex = nextVersionComponentIter.next().inVertex(); + String fetchedVersion = (String) nextVersionVertex.property(GraphPropertyEnum.VERSION.getProperty()).value(); + String fetchedName = (String) nextVersionVertex.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty()).value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to checkout component {} with version {}. The component with name {} and version {} was fetched from graph as existing following version. ", + toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString(), toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION).toString(), fetchedName, fetchedVersion); + result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS); + } + if (result == null) { + toscaElementVertex.getOrSetDefaultInstantiationTypeForToscaElementJson(); + cloneResult = operation.cloneToscaElement(toscaElementVertex, cloneGraphVertexForCheckout(toscaElementVertex, modifierVertex), modifierVertex); + if (cloneResult.isRight()) { + result = Either.right(cloneResult.right().value()); + } + } + GraphVertex clonedVertex = null; + if (result == null) { + clonedVertex = cloneResult.left().value(); + JanusGraphOperationStatus + status = janusGraphDao + .createEdge(toscaElementVertex.getVertex(), cloneResult.left().value().getVertex(), EdgeLabelEnum.VERSION, new HashMap<>()); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION, + toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), cloneResult.left().value().getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + Boolean isHighest = (Boolean) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + GraphVertex prevVersionInCatalog = (isHighest != null && isHighest) ? null : toscaElementVertex; + StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRoot(clonedVertex, prevVersionInCatalog); + if (updateCatalogRes != StorageOperationStatus.OK) { + return Either.right(updateCatalogRes); + } + result = operation.getToscaElement(cloneResult.left().value().getUniqueId()); + if (result.isRight()) { + return result; + } + ToscaElement toscaElement = result.left().value(); + if (toscaElement.getToscaType() == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE) { + result = handleFixTopologyTemplate(toscaElementVertex, result, operation, clonedVertex, toscaElement); + } + } + + return result; + } + + private Either handleFixTopologyTemplate(GraphVertex toscaElementVertex, Either result, ToscaElementOperation operation, GraphVertex clonedVertex, + ToscaElement toscaElement) { + TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; + Map instInputs = topologyTemplate.getInstInputs(); + Map instGroups = topologyTemplate.getInstGroups(); + Map instArtifactsMap = topologyTemplate.getInstanceArtifacts(); + Map origCompMap = new HashMap<>(); + if (instInputs == null) { + instInputs = new HashMap<>(); + } + if (instGroups == null) { + instGroups = new HashMap<>(); + } + if (instArtifactsMap == null) { + instArtifactsMap = new HashMap<>(); + } + Map instancesMap = topologyTemplate.getComponentInstances(); + boolean isAddInstGroup = instGroups == null || instGroups.isEmpty(); + boolean needUpdateComposition = false; + + if (instancesMap != null && !instancesMap.isEmpty()) { + for (ComponentInstanceDataDefinition vfInst : instancesMap.values()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "vfInst name is {} . OriginType {}. ", vfInst.getName(), vfInst.getOriginType()); + if (vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) { + collectInstanceInputAndGroups(instInputs, instGroups, instArtifactsMap, origCompMap, isAddInstGroup, vfInst, clonedVertex); + } + needUpdateComposition = needUpdateComposition || fixToscaComponentName(vfInst, origCompMap); + if (needUpdateComposition) { + instancesMap.put(vfInst.getUniqueId(), vfInst); + } + } + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add to graph instInputs {} instGroups {} needUpdateComposition {}", instInputs, instGroups, needUpdateComposition); + if (!instInputs.isEmpty()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst inputs {} ", instInputs == null ? 0 : instInputs.size()); + GraphVertex toscaDataVertex = null; + Either instInpVertexEither = janusGraphDao + .getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_INPUTS, JsonParseFlagEnum.ParseJson); + if (instInpVertexEither.isLeft()) { + toscaDataVertex = instInpVertexEither.left().value(); + } + + StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_INPUTS, EdgeLabelEnum.INST_INPUTS, toscaDataVertex, instInputs); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instance inputs . Status is {}. ", status); + result = Either.right(status); + return result; + } + + } + if (!instGroups.isEmpty()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst groups {} ", instGroups == null ? 0 : instGroups.size()); + GraphVertex toscaDataVertex = null; + Either instGrVertexEither = janusGraphDao + .getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_GROUPS, JsonParseFlagEnum.ParseJson); + if (instGrVertexEither.isLeft()) { + toscaDataVertex = instGrVertexEither.left().value(); + } + + StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_GROUPS, EdgeLabelEnum.INST_GROUPS, toscaDataVertex, instGroups); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instance group . Status is {}. ", status); + result = Either.right(status); + return result; + } + + } + if (needUpdateComposition) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before update Instances "); + Map jsonComposition = (Map) clonedVertex.getJson(); + CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + compositionDataDefinition.setComponentInstances(instancesMap); + Either updateElement = janusGraphDao.updateVertex(clonedVertex); + if (updateElement.isRight()) { + JanusGraphOperationStatus status = updateElement.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instances on metadata vertex . Status is {}. ", status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + } + + result = operation.getToscaElement(clonedVertex.getUniqueId()); + + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "RI map empty on component {}", toscaElement.getUniqueId()); + } + return result; + } + + // TODO remove after jsonModelMigration + public boolean resolveToscaComponentName(ComponentInstanceDataDefinition vfInst, Map origCompMap) { + return fixToscaComponentName(vfInst, origCompMap); + } + + private boolean fixToscaComponentName(ComponentInstanceDataDefinition vfInst, Map origCompMap) { + if (vfInst.getToscaComponentName() == null || vfInst.getToscaComponentName().isEmpty()) { + String ciUid = vfInst.getUniqueId(); + String origCompUid = vfInst.getComponentUid(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "fixToscaComponentName:: Ri id {} . origin component id is {}. type is{} ", ciUid, origCompUid, vfInst.getOriginType()); + ToscaElement origComp = null; + if (!origCompMap.containsKey(origCompUid)) { + Either origCompEither; + if (vfInst.getOriginType() == null || vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) { + origCompEither = topologyTemplateOperation.getToscaElement(origCompUid); + } else { + origCompEither = nodeTypeOperation.getToscaElement(origCompUid); + } + if (origCompEither.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value()); + return false; + } + origComp = origCompEither.left().value(); + origCompMap.put(origCompUid, origComp); + } else { + origComp = origCompMap.get(origCompUid); + } + String toscaName = (String) origComp.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Origin component id is {}. toscaName {}", origCompUid, toscaName); + vfInst.setToscaComponentName(toscaName); + return true; + } + return false; + } + + private void collectInstanceInputAndGroups(Map instInputs, Map instGroups, Map instArtifactsMap, Map origCompMap, + boolean isAddInstGroup, ComponentInstanceDataDefinition vfInst, GraphVertex clonedVertex) { + String ciUid = vfInst.getUniqueId(); + String origCompUid = vfInst.getComponentUid(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "collectInstanceInputAndGroups:: Ri id {} . origin component id is {}. ", ciUid, origCompUid); + TopologyTemplate origComp = null; + if (!origCompMap.containsKey(origCompUid)) { + Either origCompEither = topologyTemplateOperation.getToscaElement(origCompUid); + if (origCompEither.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value()); + return; + } + origComp = (TopologyTemplate) origCompEither.left().value(); + origCompMap.put(origCompUid, origComp); + } else { + origComp = (TopologyTemplate) origCompMap.get(origCompUid); + } + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Orig component {}. ", origComp.getUniqueId()); + + Map origInputs = origComp.getInputs(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Orig component inputs size {}. ", origInputs == null ? 0 : origInputs.size()); + if (origInputs != null) { + if (!instInputs.containsKey(ciUid)) { + MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(origInputs); + instInputs.put(ciUid, instProperties); + } else { + + MapPropertiesDataDefinition instInputMap = instInputs.get(ciUid); + Map instProp = instInputMap.getMapToscaDataDefinition(); + origInputs.forEach((propName, propMap) -> { + if (!instProp.containsKey(propName)) { + instProp.put(propName, propMap); + } + }); + } + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "ComponentInstanseInputs {}. ", instInputs.get(ciUid)); + } + + if (isAddInstGroup) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before create group instance. "); + List filteredGroups = null; + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups before filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); + if (origComp.getGroups() != null && !origComp.getGroups().isEmpty()) { + filteredGroups = origComp.getGroups().values().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList()); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups . Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); + } + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups after filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); + if (CollectionUtils.isNotEmpty(filteredGroups)) { + MapArtifactDataDefinition instArifacts = null; + if (!instArtifactsMap.containsKey(ciUid)) { + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "istance artifacts not found "); + + Map deploymentArtifacts = origComp.getDeploymentArtifacts(); + + instArifacts = new MapArtifactDataDefinition(deploymentArtifacts); + addToscaDataDeepElementsBlockToToscaElement(clonedVertex, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, instArifacts, ciUid); + + instArtifactsMap.put(ciUid, instArifacts); + + } else { + instArifacts = instArtifactsMap.get(ciUid); + } + + if (instArifacts != null) { + Map instDeplArtifMap = instArifacts.getMapToscaDataDefinition(); + + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check group dep artifacts. Size is {} ", instDeplArtifMap == null ? 0 : instDeplArtifMap.values().size()); + Map groupInstanceToCreate = new HashMap<>(); + for (GroupDataDefinition group : filteredGroups) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "create new groupInstance {} ", group.getName()); + GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition(group, vfInst, instDeplArtifMap); + List artifactsUid = new ArrayList<>(); + List artifactsId = new ArrayList<>(); + if (instDeplArtifMap!=null) { + for (ArtifactDataDefinition artifact : instDeplArtifMap.values()) { + Optional op = group.getArtifacts().stream().filter(p -> p.equals(artifact.getGeneratedFromId())).findAny(); + if (op.isPresent()) { + artifactsUid.add(artifact.getArtifactUUID()); + artifactsId.add(artifact.getUniqueId()); + + } + } + } + groupInstance.setGroupInstanceArtifacts(artifactsId); + groupInstance.setGroupInstanceArtifactsUuid(artifactsUid); + groupInstanceToCreate.put(groupInstance.getName(), groupInstance); + } + if (MapUtils.isNotEmpty(groupInstanceToCreate)) { + instGroups.put(vfInst.getUniqueId(), new MapGroupsDataDefinition(groupInstanceToCreate)); + + } + } + } + } + } + + private GraphVertex cloneGraphVertexForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) { + GraphVertex nextVersionToscaElementVertex = new GraphVertex(); + String uniqueId = UniqueIdBuilder.buildComponentUniqueId(); + Map metadataProperties = new HashMap<>(toscaElementVertex.getMetadataProperties()); + nextVersionToscaElementVertex.setMetadataProperties(metadataProperties); + nextVersionToscaElementVertex.setUniqueId(uniqueId); + nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel()); + nextVersionToscaElementVertex.setType(toscaElementVertex.getType()); + + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name()); + String nextVersion = getNextVersion((String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION)); + if (isFirstCheckoutAfterCertification(nextVersion)) { + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UUID, IdBuilderUtils.generateUUID()); + } + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, nextVersion); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name()); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) { + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name()); + } + if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) { + nextVersionToscaElementVertex.setMetadataJson(new HashMap<>(toscaElementVertex.getMetadataJson())); + nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties(); + } + long currTime = System.currentTimeMillis(); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, currTime); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, currTime); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId()); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId()); + if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE) { + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CONFORMANCE_LEVEL, ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel()); + } + + if (!MapUtils.isEmpty(toscaElementVertex.getJson())) { + nextVersionToscaElementVertex.setJson(new HashMap(toscaElementVertex.getJson())); + } + return nextVersionToscaElementVertex; + } + + private Either cloneToscaElementForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) { + Either result; + Either, StorageOperationStatus> deleteResult = null; + GraphVertex clonedToscaElement = null; + result = getToscaElementOperation(toscaElementVertex.getLabel()).cloneToscaElement(toscaElementVertex, cloneGraphVertexForCertify(toscaElementVertex, modifierVertex, majorVersion), modifierVertex); + if (result.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element {} for certification. Sattus is {}. ", toscaElementVertex.getUniqueId(), result.right().value()); + } else { + clonedToscaElement = result.left().value(); + StorageOperationStatus updateEdgeToCatalog = updateEdgeToCatalogRoot(clonedToscaElement, toscaElementVertex); + if (updateEdgeToCatalog != StorageOperationStatus.OK) { + return Either.right(updateEdgeToCatalog); + } + deleteResult = deleteAllPreviousNotCertifiedVersions(toscaElementVertex); + if (deleteResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete all previous npt certified versions of tosca element {}. Status is {}. ", toscaElementVertex.getUniqueId(), deleteResult.right().value()); + result = Either.right(deleteResult.right().value()); + } + } + if (result.isLeft()) { + result = handlePreviousVersionRelation(clonedToscaElement, deleteResult.left().value(), majorVersion); + } + return result; + } + + private Either handlePreviousVersionRelation(GraphVertex clonedToscaElement, List deletedVersions, Integer majorVersion) { + Either result = null; + Vertex previousCertifiedToscaElement = null; + if (majorVersion > 0) { + List firstMinorVersionVertex = deletedVersions.stream().filter(gv -> getMinorVersion((String) gv.getMetadataProperty(GraphPropertyEnum.VERSION)) == 1).collect(Collectors.toList()); + + if (CollectionUtils.isEmpty(firstMinorVersionVertex)) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } else { + previousCertifiedToscaElement = getPreviousCertifiedToscaElement(firstMinorVersionVertex.get(0)); + if (previousCertifiedToscaElement == null) { + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + if (result == null) { + JanusGraphOperationStatus + status = janusGraphDao + .createEdge(previousCertifiedToscaElement, clonedToscaElement.getVertex(), EdgeLabelEnum.VERSION, new HashMap<>()); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION, + previousCertifiedToscaElement.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), clonedToscaElement.getUniqueId(), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + + } + if (result == null) { + result = Either.left(clonedToscaElement); + } + return result; + } + + private Vertex getPreviousCertifiedToscaElement(GraphVertex graphVertex) { + + Iterator edges = graphVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name()); + if (edges.hasNext()) { + return edges.next().outVertex(); + } + return null; + } + + private Either, StorageOperationStatus> deleteAllPreviousNotCertifiedVersions(GraphVertex toscaElementVertex) { + Either, StorageOperationStatus> result = null; + + ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel()); + List previosVersions = null; + Object uuid = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.UUID); + Object componentName = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NAME); + try { + Map properties = new HashMap<>(); + properties.put(GraphPropertyEnum.UUID, uuid); + properties.put(GraphPropertyEnum.NAME, componentName); + Either, JanusGraphOperationStatus> getToscaElementsRes = janusGraphDao + .getByCriteria(toscaElementVertex.getLabel(), properties, JsonParseFlagEnum.ParseMetadata); + if (getToscaElementsRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementsRes.right().value())); + } + if (result == null) { + previosVersions = getToscaElementsRes.left().value(); + Either deleteResult = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value()); + if (deleteResult.isRight()) { + result = Either.right(deleteResult.right().value()); + } + } + if (result == null) { + result = Either.left(previosVersions); + } + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage()); + } + return result; + } + + private GraphVertex cloneGraphVertexForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) { + + GraphVertex nextVersionToscaElementVertex = new GraphVertex(); + String uniqueId = IdBuilderUtils.generateUniqueId(); + Map metadataProperties = new EnumMap<>(toscaElementVertex.getMetadataProperties()); + nextVersionToscaElementVertex.setMetadataProperties(metadataProperties); + nextVersionToscaElementVertex.setUniqueId(uniqueId); + nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel()); + nextVersionToscaElementVertex.setType(toscaElementVertex.getType()); + + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name()); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, (majorVersion + 1) + VERSION_DELIMITER + "0"); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, System.currentTimeMillis()); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, null); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId()); + nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId()); + + if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED)) { + nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name()); + } + if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) { + nextVersionToscaElementVertex.setMetadataJson(new HashMap<>(toscaElementVertex.getMetadataJson())); + nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties(); + } + if (!MapUtils.isEmpty(toscaElementVertex.getJson())) { + nextVersionToscaElementVertex.setJson(new HashMap(toscaElementVertex.getJson())); + } + return nextVersionToscaElementVertex; + } + + + private Either checkinToscaELement(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex, LifecycleStateEnum nextState) { + Either updateRelationsRes; + Either result = changeStateToCheckedIn(currState, toscaElementVertex, ownerVertex, modifierVertex); + if (result.isLeft()) { + toscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); + toscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + result = updateToscaElementVertexMetadataPropertiesAndJson(toscaElementVertex); + } + if (result.isLeft()) { + updateRelationsRes = updateLastModifierEdge(toscaElementVertex, ownerVertex, modifierVertex); + if (updateRelationsRes.isRight()) { + result = Either.right(updateRelationsRes.right().value()); + } + } + return result; + } + + private Either updateToscaElementVertexMetadataPropertiesAndJson(GraphVertex toscaElementVertex) { + + Either result; + + Either updateVertexRes = janusGraphDao.updateVertex(toscaElementVertex); + if (updateVertexRes.isRight()) { + JanusGraphOperationStatus titatStatus = updateVertexRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update state of tosca element vertex {} metadata. Status is {}", toscaElementVertex.getUniqueId(), titatStatus); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus)); + } else { + result = Either.left(updateVertexRes.left().value()); + } + return result; + } + + private Either changeStateToCheckedIn(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) { + Either result = null; + LifecycleStateEnum nextState = LifecycleStateEnum.NOT_CERTIFIED_CHECKIN; + String faileToUpdateStateMsg = "Failed to update state of tosca element {}. Status is {}"; + + if (currState == LifecycleStateEnum.READY_FOR_CERTIFICATION) { + // In case of cancel "ready for certification" remove last state edge with "STATE" property equals to "NOT_CERTIFIED_CHECKIN" + Map vertexProperties = new EnumMap<>(GraphPropertyEnum.class); + vertexProperties.put(GraphPropertyEnum.STATE, nextState); + Either deleteResult = janusGraphDao + .deleteBelongingEdgeByCriteria(toscaElementVertex, EdgeLabelEnum.LAST_STATE, vertexProperties); + if (deleteResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId(), deleteResult.right().value()); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to update last state relation"); + result = Either.right(StorageOperationStatus.INCONSISTENCY); + } + } + if (result == null) { + // Remove CHECKOUT relation + Either deleteEdgeResult = janusGraphDao + .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE); + if (deleteEdgeResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteEdgeResult.right().value())); + } + } + if (result == null) { + // Create CHECKIN relation + Map edgeProperties = new EnumMap<>(EdgePropertyEnum.class); + edgeProperties.put(EdgePropertyEnum.STATE, nextState); + JanusGraphOperationStatus + createEdgeRes = janusGraphDao + .createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.STATE, edgeProperties); + if (createEdgeRes != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes)); + } + } + if (result == null) { + result = Either.left(toscaElementVertex); + } + return result; + } + + private Either updateLastModifierEdge(GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) { + Either result = null; + if (!modifierVertex.getMetadataProperties().get(GraphPropertyEnum.USERID).equals(ownerVertex.getMetadataProperties().get(GraphPropertyEnum.USERID))) { + Either deleteEdgeRes = janusGraphDao + .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.LAST_MODIFIER); + if (deleteEdgeRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete last modifier {} to tosca element {}. Edge type is {}", ownerVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteEdgeRes.right().value())); + } + if (result == null) { + JanusGraphOperationStatus createEdgeRes = janusGraphDao + .createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); + + if (createEdgeRes != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to associate user {} to component {}. Edge type is {}", modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes)); + } else { + result = Either.left(modifierVertex); + } + } + } else { + result = Either.left(ownerVertex); + } + return result; + } + + private Map> prepareParametersToGetVerticesForCheckin(String toscaElementId, String modifierId, String ownerId) { + Map> verticesToGetParameters = new HashMap<>(); + verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseMetadata)); + verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); + verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); + return verticesToGetParameters; + } + + private Map> prepareParametersToGetVerticesForRequestCertification(String toscaElementId, String modifierId, String ownerId) { + Map> verticesToGetParameters = new HashMap<>(); + verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseAll)); + verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); + verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); + return verticesToGetParameters; + } + + private Map> prepareParametersToGetVerticesForCheckout(String toscaElementId, String modifierId, String ownerId) { + //Implementation is currently identical + return prepareParametersToGetVerticesForRequestCertification(toscaElementId,modifierId, ownerId); + } + + private String getNextCertifiedVersion(String version) { + String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); + Integer nextMajorVersion = Integer.parseInt(versionParts[0]) + 1; + return nextMajorVersion + VERSION_DELIMITER + "0"; + } + + private String getNextVersion(String currVersion) { + String[] versionParts = currVersion.split(VERSION_DELIMITER_REGEXP); + Integer minorVersion = Integer.parseInt(versionParts[1]) + 1; + return versionParts[0] + VERSION_DELIMITER + minorVersion; + } + + private Integer getMinorVersion(String version) { + String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); + return Integer.parseInt(versionParts[1]); + } + + private Integer getMajorVersion(String version) { + String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); + return Integer.parseInt(versionParts[0]); + } + + private boolean isFirstCheckoutAfterCertification(String version) { + return (Integer.parseInt(version.split(VERSION_DELIMITER_REGEXP)[0]) != 0 && Integer.parseInt(version.split(VERSION_DELIMITER_REGEXP)[1]) == 1); + } + + public Either forceCerificationOfToscaElement(String toscaElementId, String modifierId, String ownerId, String currVersion) { + Either resultUpdate = null; + Either result = null; + GraphVertex toscaElement = null; + GraphVertex modifier = null; + GraphVertex owner; + try { + Either, JanusGraphOperationStatus> getVerticesRes = janusGraphDao + .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); + if (getVerticesRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value())); + } + if (result == null) { + toscaElement = getVerticesRes.left().value().get(toscaElementId); + modifier = getVerticesRes.left().value().get(modifierId); + owner = getVerticesRes.left().value().get(ownerId); + + StorageOperationStatus status = handleRelationsUponForceCertification(toscaElement, modifier, owner); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations on certification request for tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); + } + } + if (result == null) { + LifecycleStateEnum nextState = LifecycleStateEnum.CERTIFIED; + + toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + toscaElement.addMetadataProperty(GraphPropertyEnum.VERSION, getNextCertifiedVersion(currVersion)); + + resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); + if (resultUpdate.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set lifecycle for tosca elememt {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); + result = Either.right(resultUpdate.right().value()); + } + } + if (result == null) { + ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); + result = operation.getToscaElement(toscaElement.getUniqueId()); + } + return result; + + } catch (Exception e) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during request certification tosca element {}. {}", toscaElementId, e.getMessage()); + } + return result; + } + + private StorageOperationStatus handleRelationsUponForceCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { + + StorageOperationStatus result = null; + JanusGraphOperationStatus status = janusGraphDao + .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); + if (status != JanusGraphOperationStatus.OK) { + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (result == null) { + Map properties = new EnumMap<>(EdgePropertyEnum.class); + properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFIED); + status = janusGraphDao + .createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + } + if (result == null) { + result = StorageOperationStatus.OK; + } + return result; + } + + private StorageOperationStatus updateEdgeToCatalogRootByUndoCheckout(JanusGraphVertex preV, GraphVertex curV) { + if (preV == null) { + return updateEdgeToCatalogRoot(null, curV); + } + String uniqueIdPreVer = (String) janusGraphDao + .getProperty((JanusGraphVertex) preV, GraphPropertyEnum.UNIQUE_ID.getProperty()); + LifecycleStateEnum state = LifecycleStateEnum.findState((String) janusGraphDao + .getProperty(preV, GraphPropertyEnum.STATE.getProperty())); + if (state == LifecycleStateEnum.CERTIFIED) { + return updateEdgeToCatalogRoot(null, curV); + } + return janusGraphDao.getVertexById(uniqueIdPreVer) + .either(l -> updateEdgeToCatalogRoot(l, curV), + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + private StorageOperationStatus updateEdgeToCatalogRoot(GraphVertex newVersionV, GraphVertex prevVersionV) { + Either catalog = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT); + if (catalog.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch catalog vertex. error {}", catalog.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(catalog.right().value()); + } + GraphVertex catalogV = catalog.left().value(); + if (newVersionV != null) { + Boolean isAbstract = (Boolean) newVersionV.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); + + if ( isAbstract == null || !isAbstract ) { + // no new vertex, only delete previous + JanusGraphOperationStatus + result = janusGraphDao + .createEdge(catalogV, newVersionV, EdgeLabelEnum.CATALOG_ELEMENT, null); + if (result != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge from {} to catalog vertex. error {}", newVersionV.getUniqueId(), result); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(result); + } + } + } + if (prevVersionV != null) { + Boolean isAbstract = (Boolean) prevVersionV.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); + if (isAbstract == null || !isAbstract) { + // if prev == null -> new resource was added + Either deleteResult = janusGraphDao + .deleteEdge(catalogV, prevVersionV, EdgeLabelEnum.CATALOG_ELEMENT); + if (deleteResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge from {} to catalog vertex. error {}", prevVersionV.getUniqueId(), deleteResult.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteResult.right().value()); + } + } + } + return StorageOperationStatus.OK; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperation.java new file mode 100644 index 0000000000..791db33d66 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperation.java @@ -0,0 +1,1405 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.category.SubCategoryDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +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.UniqueIdBuilder; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.util.StopWatch; + +import java.lang.reflect.Type; +import java.util.*; +import java.util.Map.Entry; +import java.util.stream.Collectors; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public abstract class ToscaElementOperation extends BaseOperation { + private static final String FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR = "failed to fetch {} for tosca element with id {}, error {}"; + + private static final String CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS = "Cannot find user {} in the graph. status is {}"; + + private static final String FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS = "Failed to create edge with label {} from user vertex {} to tosca element vertex {} on graph. Status is {}. "; + + private static Logger log = Logger.getLogger(ToscaElementOperation.class.getName()); + + private static final Gson gson = new Gson(); + + @Autowired + protected CategoryOperation categoryOperation; + + protected Gson getGson() { + return gson; + } + + + protected Either getComponentByLabelAndId(String uniqueId, ToscaElementTypeEnum nodeType, JsonParseFlagEnum parseFlag) { + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.UNIQUE_ID, uniqueId); + + VertexTypeEnum vertexType = ToscaElementTypeEnum.getVertexTypeByToscaType(nodeType); + Either, JanusGraphOperationStatus> getResponse = janusGraphDao + .getByCriteria(vertexType, propertiesToMatch, parseFlag); + if (getResponse.isRight()) { + log.debug("Couldn't fetch component with type {} and unique id {}, error: {}", vertexType, uniqueId, getResponse.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getResponse.right().value())); + + } + List componentList = getResponse.left().value(); + if (componentList.isEmpty()) { + log.debug("Component with type {} and unique id {} was not found", vertexType, uniqueId); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + GraphVertex vertexG = componentList.get(0); + return Either.left(vertexG); + } + + public Either getToscaElement(String uniqueId) { + return getToscaElement(uniqueId, new ComponentParametersView()); + } + + public Either markComponentToDelete(GraphVertex componentToDelete) { + Either result = null; + + Boolean isDeleted = (Boolean) componentToDelete.getMetadataProperty(GraphPropertyEnum.IS_DELETED); + if (isDeleted != null && isDeleted && !(Boolean) componentToDelete.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION)) { + // component already marked for delete + result = Either.left(componentToDelete); + return result; + } else { + + componentToDelete.addMetadataProperty(GraphPropertyEnum.IS_DELETED, Boolean.TRUE); + componentToDelete.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + + Either updateNode = janusGraphDao.updateVertex(componentToDelete); + + StorageOperationStatus updateComponent; + if (updateNode.isRight()) { + log.debug("Failed to update component {}. status is {}", componentToDelete.getUniqueId(), updateNode.right().value()); + updateComponent = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value()); + result = Either.right(updateComponent); + return result; + } + + result = Either.left(componentToDelete); + return result; + } + } + + /** + * Performs a shadow clone of previousToscaElement + * + * @param previousToscaElement + * @param nextToscaElement + * @param user + * @return + */ + public Either cloneToscaElement(GraphVertex previousToscaElement, GraphVertex nextToscaElement, GraphVertex user) { + + Either result = null; + GraphVertex createdToscaElementVertex = null; + JanusGraphOperationStatus status; + + Either createNextVersionRes = janusGraphDao.createVertex(nextToscaElement); + if (createNextVersionRes.isRight()) { + status = createNextVersionRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create tosca element vertex {} with version {} on graph. Status is {}. ", previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), + previousToscaElement.getMetadataProperty(GraphPropertyEnum.VERSION), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + createdToscaElementVertex = createNextVersionRes.left().value(); + Map properties = new HashMap<>(); + properties.put(EdgePropertyEnum.STATE, createdToscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE)); + status = janusGraphDao + .createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.STATE, properties); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.STATE, user.getUniqueId(), + previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + status = janusGraphDao + .createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.LAST_MODIFIER, user.getUniqueId(), + nextToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + status = janusGraphDao + .createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.CREATOR, new HashMap<>()); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.CREATOR, user.getUniqueId(), + nextToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (result == null) { + Iterator edgesToCopyIter = previousToscaElement.getVertex().edges(Direction.OUT); + while (edgesToCopyIter.hasNext()) { + Edge currEdge = edgesToCopyIter.next(); + Vertex currVertex = currEdge.inVertex(); + status = janusGraphDao + .createEdge(createdToscaElementVertex.getVertex(), currVertex, EdgeLabelEnum.getEdgeLabelEnum(currEdge.label()), currEdge); + if (status != JanusGraphOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from tosca element vertex {} to vertex with label {} on graph. Status is {}. ", currEdge.label(), createdToscaElementVertex.getUniqueId(), + currVertex.property(GraphPropertyEnum.LABEL.getProperty()), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + break; + } + } + } + + if (result == null) { + result = Either.left(createdToscaElementVertex); + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element {} with the name {}. ", previousToscaElement.getUniqueId(), previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME)); + } + return result; + } + + protected JanusGraphOperationStatus setLastModifierFromGraph(GraphVertex componentV, ToscaElement toscaElement) { + Either parentVertex = janusGraphDao + .getParentVertex(componentV, EdgeLabelEnum.LAST_MODIFIER, JsonParseFlagEnum.NoParse); + if (parentVertex.isRight()) { + log.debug("Failed to fetch last modifier for tosca element with id {} error {}", componentV.getUniqueId(), parentVertex.right().value()); + return parentVertex.right().value(); + } + GraphVertex userV = parentVertex.left().value(); + String userId = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); + toscaElement.setLastUpdaterUserId(userId); + toscaElement.setLastUpdaterFullName(buildFullName(userV)); + return JanusGraphOperationStatus.OK; + } + + public String buildFullName(GraphVertex userV) { + + String fullName = (String) userV.getMetadataProperty(GraphPropertyEnum.FIRST_NAME); + if (fullName == null) { + fullName = ""; + } else { + fullName = fullName + " "; + } + String lastName = (String) userV.getMetadataProperty(GraphPropertyEnum.LAST_NAME); + if (lastName != null) { + fullName += lastName; + } + return fullName; + } + + protected JanusGraphOperationStatus setCreatorFromGraph(GraphVertex componentV, ToscaElement toscaElement) { + Either parentVertex = janusGraphDao + .getParentVertex(componentV, EdgeLabelEnum.CREATOR, JsonParseFlagEnum.NoParse); + if (parentVertex.isRight()) { + log.debug("Failed to fetch creator for tosca element with id {} error {}", componentV.getUniqueId(), parentVertex.right().value()); + return parentVertex.right().value(); + } + GraphVertex userV = parentVertex.left().value(); + String creatorUserId = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); + toscaElement.setCreatorUserId(creatorUserId); + toscaElement.setCreatorFullName(buildFullName(userV)); + + return JanusGraphOperationStatus.OK; + } + + protected T getResourceMetaDataFromResource(T toscaElement) { + if (toscaElement.getNormalizedName() == null || toscaElement.getNormalizedName().isEmpty()) { + toscaElement.setNormalizedName(ValidationUtils.normaliseComponentName(toscaElement.getName())); + } + if (toscaElement.getSystemName() == null || toscaElement.getSystemName().isEmpty()) { + toscaElement.setSystemName(ValidationUtils.convertToSystemName(toscaElement.getName())); + } + + LifecycleStateEnum lifecycleStateEnum = toscaElement.getLifecycleState(); + if (lifecycleStateEnum == null) { + toscaElement.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + } + long currentDate = System.currentTimeMillis(); + if (toscaElement.getCreationDate() == null) { + toscaElement.setCreationDate(currentDate); + } + toscaElement.setLastUpdateDate(currentDate); + + return toscaElement; + } + + protected void fillCommonMetadata(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { + if (toscaElement.isHighestVersion() == null) { + toscaElement.setHighestVersion(true); + } + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_DELETED, toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, toscaElement.getMetadataValueOrDefault(JsonPresentationFields.HIGHEST_VERSION, Boolean.TRUE)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.STATE, toscaElement.getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.RESOURCE_TYPE, toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_TYPE)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.VERSION, toscaElement.getMetadataValue(JsonPresentationFields.VERSION)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME, toscaElement.getMetadataValue(JsonPresentationFields.NORMALIZED_NAME)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, toscaElement.getMetadataValue(JsonPresentationFields.UNIQUE_ID)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.UUID, toscaElement.getMetadataValue(JsonPresentationFields.UUID)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_ABSTRACT, toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.INVARIANT_UUID, toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.NAME, toscaElement.getMetadataValue(JsonPresentationFields.NAME)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.SYSTEM_NAME, toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_ARCHIVED, toscaElement.getMetadataValue(JsonPresentationFields.IS_ARCHIVED)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME, toscaElement.getMetadataValue(JsonPresentationFields.ARCHIVE_TIME)); + nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED, toscaElement.getMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED)); + toscaElement.getMetadata().entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> nodeTypeVertex.setJsonMetadataField(JsonPresentationFields.getByPresentation(e.getKey()), e.getValue())); + + nodeTypeVertex.setUniqueId(toscaElement.getUniqueId()); + nodeTypeVertex.setType(toscaElement.getComponentType()); + + } + + protected StorageOperationStatus assosiateToUsers(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { + // handle user + String userId = toscaElement.getCreatorUserId(); + + Either findUser = findUserVertex(userId); + + if (findUser.isRight()) { + JanusGraphOperationStatus status = findUser.right().value(); + log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, userId, status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + + } + GraphVertex creatorVertex = findUser.left().value(); + GraphVertex updaterVertex = creatorVertex; + String updaterId = toscaElement.getLastUpdaterUserId(); + if (updaterId != null && !updaterId.equals(userId)) { + findUser = findUserVertex(updaterId); + if (findUser.isRight()) { + JanusGraphOperationStatus status = findUser.right().value(); + log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, userId, status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } else { + updaterVertex = findUser.left().value(); + } + } + Map props = new EnumMap<>(EdgePropertyEnum.class); + props.put(EdgePropertyEnum.STATE, (String) toscaElement.getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); + + JanusGraphOperationStatus + result = janusGraphDao + .createEdge(updaterVertex, nodeTypeVertex, EdgeLabelEnum.STATE, props); + log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.STATE); + if (JanusGraphOperationStatus.OK != result) { + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(result); + } + result = janusGraphDao + .createEdge(updaterVertex, nodeTypeVertex, EdgeLabelEnum.LAST_MODIFIER, null); + log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); + if (!result.equals(JanusGraphOperationStatus.OK)) { + log.error("Failed to associate user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(result); + } + + toscaElement.setLastUpdaterUserId(toscaElement.getCreatorUserId()); + toscaElement.setLastUpdaterFullName(toscaElement.getCreatorFullName()); + + result = janusGraphDao.createEdge(creatorVertex, nodeTypeVertex, EdgeLabelEnum.CREATOR, null); + log.debug("After associating user {} to resource {}. Edge type is {} ", creatorVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.CREATOR); + if (!result.equals(JanusGraphOperationStatus.OK)) { + log.error("Failed to associate user {} to resource {}. Edge type is {} ", creatorVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.CREATOR); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(result); + } + return StorageOperationStatus.OK; + } + + protected StorageOperationStatus assosiateResourceMetadataToCategory(GraphVertex nodeTypeVertex, ToscaElement nodeType) { + String subcategoryName = nodeType.getCategories().get(0).getSubcategories().get(0).getName(); + String categoryName = nodeType.getCategories().get(0).getName(); + Either getCategoryVertex = getResourceCategoryVertex(nodeType.getUniqueId(), subcategoryName, categoryName); + + if (getCategoryVertex.isRight()) { + return getCategoryVertex.right().value(); + } + + GraphVertex subCategoryV = getCategoryVertex.left().value(); + + JanusGraphOperationStatus + createEdge = janusGraphDao + .createEdge(nodeTypeVertex, subCategoryV, EdgeLabelEnum.CATEGORY, new HashMap<>()); + if (createEdge != JanusGraphOperationStatus.OK) { + log.trace("Failed to associate resource {} to category {} with id {}", nodeType.getUniqueId(), subcategoryName, subCategoryV.getUniqueId()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge); + } + return StorageOperationStatus.OK; + } + + protected Either getResourceCategoryVertex(String elementId, String subcategoryName, String categoryName) { + Either category = categoryOperation.getCategory(categoryName, VertexTypeEnum.RESOURCE_CATEGORY); + if (category.isRight()) { + log.trace("Failed to fetch category {} for resource {} error {}", categoryName, elementId, category.right().value()); + return Either.right(category.right().value()); + } + GraphVertex categoryV = category.left().value(); + + if (subcategoryName != null) { + Either subCategory = categoryOperation.getSubCategoryForCategory(categoryV, subcategoryName); + if (subCategory.isRight()) { + log.trace("Failed to fetch subcategory {} of category for resource {} error {}", subcategoryName, categoryName, elementId, subCategory.right().value()); + return Either.right(subCategory.right().value()); + } + + GraphVertex subCategoryV = subCategory.left().value(); + return Either.left(subCategoryV); + } + return Either.left(categoryV); + } + + private StorageOperationStatus associateArtifactsToResource(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { + Map artifacts = toscaElement.getArtifacts(); + Either status; + if (artifacts != null) { + artifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { + String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); + a.setUniqueId(uniqueId); + }); + status = associateElementToData(nodeTypeVertex, VertexTypeEnum.ARTIFACTS, EdgeLabelEnum.ARTIFACTS, artifacts); + if (status.isRight()) { + return status.right().value(); + } + } + Map toscaArtifacts = toscaElement.getToscaArtifacts(); + if (toscaArtifacts != null) { + toscaArtifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { + String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); + a.setUniqueId(uniqueId); + }); + status = associateElementToData(nodeTypeVertex, VertexTypeEnum.TOSCA_ARTIFACTS, EdgeLabelEnum.TOSCA_ARTIFACTS, toscaArtifacts); + if (status.isRight()) { + return status.right().value(); + } + } + Map deploymentArtifacts = toscaElement.getDeploymentArtifacts(); + if (deploymentArtifacts != null) { + deploymentArtifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { + String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); + a.setUniqueId(uniqueId); + }); + status = associateElementToData(nodeTypeVertex, VertexTypeEnum.DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS, deploymentArtifacts); + if (status.isRight()) { + return status.right().value(); + } + } + return StorageOperationStatus.OK; + } + + protected JanusGraphOperationStatus disassociateAndDeleteCommonElements(GraphVertex toscaElementVertex) { + JanusGraphOperationStatus + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate artifact for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.TOSCA_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate tosca artifact for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to deployment artifact for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.PROPERTIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate properties for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ATTRIBUTES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate attributes for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate additional information for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate capabilities for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.REQUIREMENTS); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + status = janusGraphDao + .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FORWARDING_PATH); + if (status != JanusGraphOperationStatus.OK) { + log.debug("Failed to disaccociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); + return status; + } + return JanusGraphOperationStatus.OK; + } + + protected StorageOperationStatus assosiateCommonForToscaElement(GraphVertex nodeTypeVertex, ToscaElement toscaElement, List derivedResources) { + + StorageOperationStatus associateUsers = assosiateToUsers(nodeTypeVertex, toscaElement); + if (associateUsers != StorageOperationStatus.OK) { + return associateUsers; + } + StorageOperationStatus associateArtifacts = associateArtifactsToResource(nodeTypeVertex, toscaElement); + if (associateArtifacts != StorageOperationStatus.OK) { + return associateArtifacts; + } + StorageOperationStatus associateProperties = associatePropertiesToResource(nodeTypeVertex, toscaElement, derivedResources); + if (associateProperties != StorageOperationStatus.OK) { + return associateProperties; + } + StorageOperationStatus associateAdditionaInfo = associateAdditionalInfoToResource(nodeTypeVertex, toscaElement); + if (associateAdditionaInfo != StorageOperationStatus.OK) { + return associateAdditionaInfo; + } + if (needConnectToCatalog(toscaElement)) { + StorageOperationStatus associateToCatalog = associateToCatalogRoot(nodeTypeVertex); + if (associateToCatalog != StorageOperationStatus.OK) { + return associateToCatalog; + } + } + return StorageOperationStatus.OK; + } + + private boolean needConnectToCatalog(ToscaElement toscaElement) { + Boolean isAbstract = (Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT); + if (isAbstract != null && isAbstract) { + return false; + } + return toscaElement.isHighestVersion(); + } + + private StorageOperationStatus associateToCatalogRoot(GraphVertex nodeTypeVertex) { + Either catalog = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT); + if (catalog.isRight()) { + log.debug("Failed to fetch catalog vertex. error {}", catalog.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(catalog.right().value()); + } + JanusGraphOperationStatus + createEdge = janusGraphDao + .createEdge(catalog.left().value(), nodeTypeVertex, EdgeLabelEnum.CATALOG_ELEMENT, null); + + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge); + } + + protected StorageOperationStatus associatePropertiesToResource(GraphVertex nodeTypeVertex, ToscaElement nodeType, List derivedResources) { + // Note : currently only one derived supported!!!! + Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.PROPERTIES); + if (dataFromDerived.isRight()) { + return dataFromDerived.right().value(); + } + Map propertiesAll = dataFromDerived.left().value(); + + Map properties = nodeType.getProperties(); + + if (properties != null) { + properties.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { + String uid = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId(), p.getName()); + p.setUniqueId(uid); + }); + + Either, String> eitherMerged = ToscaDataDefinition.mergeDataMaps(propertiesAll, properties); + if (eitherMerged.isRight()) { + // TODO re-factor error handling - moving BL to operation resulted in loss of info about the invalid property + log.debug("property {} cannot be overriden", eitherMerged.right().value()); + return StorageOperationStatus.INVALID_PROPERTY; + } + } + if (!propertiesAll.isEmpty()) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.PROPERTIES, EdgeLabelEnum.PROPERTIES, propertiesAll); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus associateAdditionalInfoToResource(GraphVertex nodeTypeVertex, ToscaElement nodeType) { + Map additionalInformation = nodeType.getAdditionalInformation(); + if (additionalInformation != null) { + Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, additionalInformation); + if (assosiateElementToData.isRight()) { + return assosiateElementToData.right().value(); + } + } + return StorageOperationStatus.OK; + } + + protected Either, StorageOperationStatus> getDataFromDerived(List derivedResources, EdgeLabelEnum edge) { + Map propertiesAll = new HashMap<>(); + + if (derivedResources != null && !derivedResources.isEmpty()) { + for (GraphVertex derived : derivedResources) { + Either, JanusGraphOperationStatus> derivedProperties = janusGraphDao + .getChildrenVertecies(derived, edge, JsonParseFlagEnum.ParseJson); + if (derivedProperties.isRight()) { + if (derivedProperties.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("Failed to get properties for derived from {} error {}", derived.getUniqueId(), derivedProperties.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(derivedProperties.right().value())); + } else { + continue; + } + } + List propList = derivedProperties.left().value(); + for (GraphVertex propV : propList) { + Map propertiesFromDerived = (Map) propV.getJson(); + if (propertiesFromDerived != null) { + propertiesFromDerived.entrySet().forEach(x -> x.getValue().setOwnerIdIfEmpty(derived.getUniqueId())); + propertiesAll.putAll(propertiesFromDerived); + } + } + } + } + return Either.left(propertiesAll); + } + + protected JanusGraphOperationStatus setArtifactsFromGraph(GraphVertex componentV, ToscaElement toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ARTIFACTS); + if (result.isLeft()) { + toscaElement.setArtifacts(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + result = getDataFromGraph(componentV, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); + if (result.isLeft()) { + toscaElement.setDeploymentArtifacts(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + result = getDataFromGraph(componentV, EdgeLabelEnum.TOSCA_ARTIFACTS); + if (result.isLeft()) { + toscaElement.setToscaArtifacts(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + protected JanusGraphOperationStatus setAllVersions(GraphVertex componentV, ToscaElement toscaElement) { + Map allVersion = new HashMap<>(); + + allVersion.put((String) componentV.getMetadataProperty(GraphPropertyEnum.VERSION), componentV.getUniqueId()); + ArrayList allChildrenAndParants = new ArrayList<>(); + Either childResourceRes = janusGraphDao + .getChildVertex(componentV, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + while (childResourceRes.isLeft()) { + GraphVertex child = childResourceRes.left().value(); + allChildrenAndParants.add(child); + childResourceRes = janusGraphDao + .getChildVertex(child, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + } + JanusGraphOperationStatus operationStatus = childResourceRes.right().value(); + + if (operationStatus != JanusGraphOperationStatus.NOT_FOUND) { + return operationStatus; + } else { + Either parentResourceRes = janusGraphDao + .getParentVertex(componentV, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + while (parentResourceRes.isLeft()) { + GraphVertex parent = parentResourceRes.left().value(); + allChildrenAndParants.add(parent); + parentResourceRes = janusGraphDao + .getParentVertex(parent, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + } + operationStatus = parentResourceRes.right().value(); + if (operationStatus != JanusGraphOperationStatus.NOT_FOUND) { + return operationStatus; + } else { + allChildrenAndParants.stream().filter(vertex -> { + Boolean isDeleted = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_DELETED); + return (isDeleted == null || !isDeleted); + }).forEach(vertex -> allVersion.put((String) vertex.getMetadataProperty(GraphPropertyEnum.VERSION), vertex.getUniqueId())); + + toscaElement.setAllVersions(allVersion); + return JanusGraphOperationStatus.OK; + } + } + } + + protected Either, StorageOperationStatus> getFollowedComponent(String userId, Set lifecycleStates, Set lastStateStates, ComponentTypeEnum neededType) { + + Either, StorageOperationStatus> result = null; + + Map props = null; + + if (userId != null) { + props = new EnumMap<>(GraphPropertyEnum.class); + // for Designer retrieve specific user + props.put(GraphPropertyEnum.USERID, userId); + } + // in case of user id == null -> get all users by label + // for Tester and Admin retrieve all users + Either, JanusGraphOperationStatus> usersByCriteria = janusGraphDao + .getByCriteria(VertexTypeEnum.USER, props, JsonParseFlagEnum.NoParse); + if (usersByCriteria.isRight()) { + log.debug("Failed to fetch users by criteria {} error {}", props, usersByCriteria.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(usersByCriteria.right().value())); + } + List users = usersByCriteria.left().value(); + + List components = new ArrayList<>(); + List componentsPerUser; + for (GraphVertex userV : users) { + + HashSet ids = new HashSet<>(); + Either, JanusGraphOperationStatus> childrenVertecies = janusGraphDao + .getChildrenVertecies(userV, EdgeLabelEnum.STATE, JsonParseFlagEnum.NoParse); + if (childrenVertecies.isRight() && childrenVertecies.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("Failed to fetch children vertices for user {} by edge {} error {}", userV.getMetadataProperty(GraphPropertyEnum.USERID), EdgeLabelEnum.STATE, childrenVertecies.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childrenVertecies.right().value())); + } + + // get all resource with current state + if (childrenVertecies.isLeft()) { + componentsPerUser = fetchComponents(lifecycleStates, childrenVertecies.left().value(), neededType, EdgeLabelEnum.STATE); + + if (componentsPerUser != null) { + for (T comp : componentsPerUser) { + ids.add(comp.getUniqueId()); + components.add(comp); + } + } + } + if (lastStateStates != null && !lastStateStates.isEmpty()) { + // get all resource with last state + childrenVertecies = janusGraphDao + .getChildrenVertecies(userV, EdgeLabelEnum.LAST_STATE, JsonParseFlagEnum.NoParse); + if (childrenVertecies.isRight() && childrenVertecies.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("Failed to fetch children vertices for user {} by edge {} error {}", userV.getMetadataProperty(GraphPropertyEnum.USERID), EdgeLabelEnum.LAST_STATE, childrenVertecies.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childrenVertecies.right().value())); + } + if (childrenVertecies.isLeft()) { + boolean isFirst; + componentsPerUser = fetchComponents(lastStateStates, childrenVertecies.left().value(), neededType, EdgeLabelEnum.LAST_STATE); + if (componentsPerUser != null) { + for (T comp : componentsPerUser) { + isFirst = true; + + if (ids.contains(comp.getUniqueId())) { + isFirst = false; + } + if (isFirst) { + components.add(comp); + } + + } + } + } + } + + } // whlile users + ; + result = Either.left(components); + return result; + + } + + private List fetchComponents(Set lifecycleStates, List vertices, ComponentTypeEnum neededType, EdgeLabelEnum edgelabel) { + List components = new ArrayList<>(); + for (GraphVertex node : vertices) { + + Iterator edges = node.getVertex().edges(Direction.IN, edgelabel.name()); + while (edges.hasNext()) { + Edge edge = edges.next(); + String stateStr = (String) janusGraphDao.getProperty(edge, EdgePropertyEnum.STATE); + + LifecycleStateEnum nodeState = LifecycleStateEnum.findState(stateStr); + if (nodeState == null) { + log.debug("no supported STATE {} for element {}", stateStr, node.getUniqueId()); + continue; + } + if (lifecycleStates != null && lifecycleStates.contains(nodeState)) { + + Boolean isDeleted = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_DELETED); + Boolean isArchived = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); + if (isDeleted != null && isDeleted || isArchived != null && isArchived) { + log.trace("Deleted/Archived element {}, discard", node.getUniqueId()); + continue; + } + + Boolean isHighest = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + if (isHighest) { + + ComponentTypeEnum componentType = node.getType(); + // get only latest versions + + if (componentType == null) { + log.debug("No supported type {} for vertex {}", componentType, node.getUniqueId()); + continue; + } + if (neededType == componentType) { + switch (componentType) { + case SERVICE: + case PRODUCT: + handleNode(components, node, componentType); + break; + case RESOURCE: + Boolean isAbtract = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); + if (isAbtract == null || !isAbtract) { + handleNode(components, node, componentType); + } // if not abstract + break; + default: + log.debug("not supported node type {}", componentType); + break; + }// case + } // needed type + } + } // if + } // while edges + } // while resources + return components; + } + + protected void handleNode(List components, GraphVertex vertexComponent, ComponentTypeEnum nodeType) { + + Either component = getLightComponent(vertexComponent, nodeType, new ComponentParametersView(true)); + if (component.isRight()) { + log.debug("Failed to get component for id = {} error : {} skip resource", vertexComponent.getUniqueId(), component.right().value()); + } else { + components.add(component.left().value()); + } + } + + protected Either getLightComponent(String componentUid, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { + Either getVertexRes = janusGraphDao.getVertexById(componentUid); + if (getVertexRes.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexRes.right().value())); + } + return getLightComponent(getVertexRes.left().value(), nodeType, parametersFilter); + } + + protected Either getLightComponent(GraphVertex vertexComponent, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { + + log.trace("Starting to build light component of type {}, id {}", nodeType, vertexComponent.getUniqueId()); + + janusGraphDao.parseVertexProperties(vertexComponent, JsonParseFlagEnum.ParseMetadata); + + T toscaElement = convertToComponent(vertexComponent); + + JanusGraphOperationStatus status = setCreatorFromGraph(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + + status = setLastModifierFromGraph(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + status = setCategoriesFromGraph(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (!parametersFilter.isIgnoreAllVersions()) { + status = setAllVersions(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!parametersFilter.isIgnoreCapabilities()) { + status = setCapabilitiesFromGraph(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + if (!parametersFilter.isIgnoreRequirements()) { + status = setRequirementsFromGraph(vertexComponent, toscaElement); + if (status != JanusGraphOperationStatus.OK) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + } + log.debug("Ended to build light component of type {}, id {}", nodeType, vertexComponent.getUniqueId()); + return Either.left(toscaElement); + } + + @SuppressWarnings("unchecked") + protected T convertToComponent(GraphVertex componentV) { + ToscaElement toscaElement = null; + VertexTypeEnum label = componentV.getLabel(); + switch (label) { + case NODE_TYPE: + toscaElement = new NodeType(); + break; + case TOPOLOGY_TEMPLATE: + toscaElement = new TopologyTemplate(); + break; + default: + log.debug("Not supported tosca type {}", label); + break; + } + + Map jsonMetada = componentV.getMetadataJson(); + if (toscaElement != null) { + toscaElement.setMetadata(jsonMetada); + } + return (T) toscaElement; + } + + protected JanusGraphOperationStatus setResourceCategoryFromGraphV(Vertex vertex, CatalogComponent catalogComponent) { + + Either childVertex = janusGraphDao + .getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, catalogComponent.getUniqueId(), childVertex.right().value()); + return childVertex.right().value(); + } + Vertex subCategoryV = childVertex.left().value(); + catalogComponent.setSubCategoryNormalizedName((String) subCategoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); + Either parentVertex = janusGraphDao + .getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); + Vertex categoryV = parentVertex.left().value(); + catalogComponent.setCategoryNormalizedName((String) categoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); + + return JanusGraphOperationStatus.OK; + } + + protected JanusGraphOperationStatus setServiceCategoryFromGraphV(Vertex vertex, CatalogComponent catalogComponent) { + Either childVertex = janusGraphDao + .getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, catalogComponent.getUniqueId(), childVertex.right().value()); + return childVertex.right().value(); + } + Vertex categoryV = childVertex.left().value(); + catalogComponent.setCategoryNormalizedName((String) categoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); + + return JanusGraphOperationStatus.OK; + } + + protected JanusGraphOperationStatus setResourceCategoryFromGraph(GraphVertex componentV, ToscaElement toscaElement) { + List categories = new ArrayList<>(); + SubCategoryDefinition subcategory; + + Either childVertex = janusGraphDao + .getChildVertex(componentV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, componentV.getUniqueId(), childVertex.right().value()); + return childVertex.right().value(); + } + GraphVertex subCategoryV = childVertex.left().value(); + Map metadataProperties = subCategoryV.getMetadataProperties(); + subcategory = new SubCategoryDefinition(); + subcategory.setUniqueId(subCategoryV.getUniqueId()); + subcategory.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); + subcategory.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); + + Type listTypeSubcat = new TypeToken>() { + }.getType(); + List iconsfromJsonSubcat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS), listTypeSubcat); + subcategory.setIcons(iconsfromJsonSubcat); + + Either parentVertex = janusGraphDao + .getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); + if (parentVertex.isRight()) { + log.debug("failed to fetch {} for category with id {}, error {}", EdgeLabelEnum.SUB_CATEGORY, subCategoryV.getUniqueId(), parentVertex.right().value()); + return childVertex.right().value(); + } + GraphVertex categoryV = parentVertex.left().value(); + metadataProperties = categoryV.getMetadataProperties(); + + CategoryDefinition category = new CategoryDefinition(); + category.setUniqueId(categoryV.getUniqueId()); + category.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); + category.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); + + Type listTypeCat = new TypeToken>() { + }.getType(); + List iconsfromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS), listTypeCat); + category.setIcons(iconsfromJsonCat); + + category.addSubCategory(subcategory); + categories.add(category); + toscaElement.setCategories(categories); + + return JanusGraphOperationStatus.OK; + } + + public Either updateToscaElement(T toscaElementToUpdate, GraphVertex elementV, ComponentParametersView filterResult) { + Either result = null; + + log.debug("In updateToscaElement. received component uid = {}", (toscaElementToUpdate == null ? null : toscaElementToUpdate.getUniqueId())); + if (toscaElementToUpdate == null) { + log.error("Service object is null"); + result = Either.right(StorageOperationStatus.BAD_REQUEST); + return result; + } + + String modifierUserId = toscaElementToUpdate.getLastUpdaterUserId(); + if (modifierUserId == null || modifierUserId.isEmpty()) { + log.error("UserId is missing in the request."); + result = Either.right(StorageOperationStatus.BAD_REQUEST); + return result; + } + Either findUser = findUserVertex(modifierUserId); + + if (findUser.isRight()) { + JanusGraphOperationStatus status = findUser.right().value(); + log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, modifierUserId, status); + return result; + } + + GraphVertex modifierV = findUser.left().value(); + String toscaElementId = toscaElementToUpdate.getUniqueId(); + + Either parentVertex = janusGraphDao + .getParentVertex(elementV, EdgeLabelEnum.LAST_MODIFIER, JsonParseFlagEnum.NoParse); + if (parentVertex.isRight()) { + log.debug("Failed to fetch last modifier for tosca element with id {} error {}", toscaElementId, parentVertex.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentVertex.right().value())); + } + GraphVertex userV = parentVertex.left().value(); + String currentModifier = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); + + String prevSystemName = (String) elementV.getMetadataProperty(GraphPropertyEnum.SYSTEM_NAME); + + if (currentModifier.equals(modifierUserId)) { + log.debug("Graph LAST MODIFIER edge should not be changed since the modifier is the same as the last modifier."); + } else { + log.debug("Going to update the last modifier user of the resource from {} to {}", currentModifier, modifierUserId); + StorageOperationStatus status = moveLastModifierEdge(elementV, modifierV); + log.debug("Finish to update the last modifier user of the resource from {} to {}. status is {}", currentModifier, modifierUserId, status); + if (status != StorageOperationStatus.OK) { + result = Either.right(status); + return result; + } + } + + final long currentTimeMillis = System.currentTimeMillis(); + log.debug("Going to update the last Update Date of the resource from {} to {}", elementV.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE), currentTimeMillis); + elementV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, currentTimeMillis); + + StorageOperationStatus checkCategories = validateCategories(toscaElementToUpdate, elementV); + if (checkCategories != StorageOperationStatus.OK) { + result = Either.right(checkCategories); + return result; + } + + // update all data on vertex + fillToscaElementVertexData(elementV, toscaElementToUpdate, JsonParseFlagEnum.ParseMetadata); + + Either updateElement = janusGraphDao.updateVertex(elementV); + + if (updateElement.isRight()) { + log.error("Failed to update resource {}. status is {}", toscaElementId, updateElement.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value())); + return result; + } + GraphVertex updateElementV = updateElement.left().value(); + + // DE230195 in case resource name changed update TOSCA artifacts + // file names accordingly + String newSystemName = (String) updateElementV.getMetadataProperty(GraphPropertyEnum.SYSTEM_NAME); + if (newSystemName != null && !newSystemName.equals(prevSystemName)) { + Either, JanusGraphOperationStatus> resultToscaArt = getDataFromGraph(updateElementV, EdgeLabelEnum.TOSCA_ARTIFACTS); + if (resultToscaArt.isRight()) { + log.debug("Failed to get tosca artifact from graph for tosca element {} error {}", toscaElementId, resultToscaArt.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resultToscaArt.right().value())); + } + + Map toscaArtifacts = resultToscaArt.left().value(); + if (toscaArtifacts != null) { + for (Entry artifact : toscaArtifacts.entrySet()) { + generateNewToscaFileName(toscaElementToUpdate.getComponentType().getValue().toLowerCase(), newSystemName, artifact.getValue()); + } + // TODO call to new Artifact operation in order to update list of artifacts + + } + } + + if (toscaElementToUpdate.getComponentType() == ComponentTypeEnum.RESOURCE) { + StorageOperationStatus resultDerived = updateDerived(toscaElementToUpdate, updateElementV); + if (resultDerived != StorageOperationStatus.OK) { + log.debug("Failed to update from derived data for element {} error {}", toscaElementId, resultDerived); + return Either.right(resultDerived); + } + } + + Either updatedResource = getToscaElement(updateElementV, filterResult); + if (updatedResource.isRight()) { + log.error("Failed to fetch tosca element {} after update , error {}", toscaElementId, updatedResource.right().value()); + result = Either.right(StorageOperationStatus.BAD_REQUEST); + return result; + } + + T updatedResourceValue = updatedResource.left().value(); + result = Either.left(updatedResourceValue); + + return result; + } + + protected StorageOperationStatus moveLastModifierEdge(GraphVertex elementV, GraphVertex modifierV) { + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphDao.moveEdge(elementV, modifierV, EdgeLabelEnum.LAST_MODIFIER, Direction.IN)); + } + + protected StorageOperationStatus moveCategoryEdge(GraphVertex elementV, GraphVertex categoryV) { + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphDao.moveEdge(elementV, categoryV, EdgeLabelEnum.CATEGORY, Direction.OUT)); + } + + private void generateNewToscaFileName(String componentType, String componentName, ArtifactDataDefinition artifactInfo) { + Map getConfig = (Map) ConfigurationManager.getConfigurationManager().getConfiguration().getToscaArtifacts().entrySet().stream().filter(p -> p.getKey().equalsIgnoreCase(artifactInfo.getArtifactLabel())) + .findAny().get().getValue(); + artifactInfo.setArtifactName(componentType + "-" + componentName + getConfig.get("artifactName")); + } + + protected StorageOperationStatus validateResourceCategory(T toscaElementToUpdate, GraphVertex elementV) { + StorageOperationStatus status = StorageOperationStatus.OK; + List newCategoryList = toscaElementToUpdate.getCategories(); + CategoryDefinition newCategory = newCategoryList.get(0); + + Either childVertex = janusGraphDao + .getChildVertex(elementV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); + if (childVertex.isRight()) { + log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, elementV.getUniqueId(), childVertex.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childVertex.right().value()); + } + GraphVertex subCategoryV = childVertex.left().value(); + Map metadataProperties = subCategoryV.getMetadataProperties(); + String subCategoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); + + Either parentVertex = janusGraphDao + .getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); + if (parentVertex.isRight()) { + log.debug("failed to fetch {} for category with id {}, error {}", EdgeLabelEnum.SUB_CATEGORY, subCategoryV.getUniqueId(), parentVertex.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(childVertex.right().value()); + } + GraphVertex categoryV = parentVertex.left().value(); + metadataProperties = categoryV.getMetadataProperties(); + String categoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); + + boolean categoryWasChanged = false; + + String newCategoryName = newCategory.getName(); + SubCategoryDefinition newSubcategory = newCategory.getSubcategories().get(0); + String newSubCategoryName = newSubcategory.getName(); + if (newCategoryName != null && !newCategoryName.equals(categoryNameCurrent)) { + // the category was changed + categoryWasChanged = true; + } else { + // the sub-category was changed + if (newSubCategoryName != null && !newSubCategoryName.equals(subCategoryNameCurrent)) { + log.debug("Going to update the category of the resource from {} to {}", categoryNameCurrent, newCategory); + categoryWasChanged = true; + } + } + if (categoryWasChanged) { + Either getCategoryVertex = getResourceCategoryVertex(elementV.getUniqueId(), newSubCategoryName, newCategoryName); + + if (getCategoryVertex.isRight()) { + return getCategoryVertex.right().value(); + } + GraphVertex newCategoryV = getCategoryVertex.left().value(); + status = moveCategoryEdge(elementV, newCategoryV); + log.debug("Going to update the category of the resource from {} to {}. status is {}", categoryNameCurrent, newCategory, status); + } + return status; + } + + public Either, StorageOperationStatus> getElementCatalogData(ComponentTypeEnum componentType, List excludeTypes, boolean isHighestVersions) { + Either, JanusGraphOperationStatus> listOfComponents; + if (isHighestVersions) { + listOfComponents = getListOfHighestComponents(componentType, excludeTypes, JsonParseFlagEnum.NoParse); + } else { + listOfComponents = getListOfHighestAndAllCertifiedComponents(componentType, excludeTypes); + } + + if (listOfComponents.isRight() && listOfComponents.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(listOfComponents.right().value())); + } + List result = new ArrayList<>(); + if (listOfComponents.isLeft()) { + List highestAndAllCertified = listOfComponents.left().value(); + if (highestAndAllCertified != null && !highestAndAllCertified.isEmpty()) { + for (GraphVertex vertexComponent : highestAndAllCertified) { + Either component = getLightComponent(vertexComponent, componentType, new ComponentParametersView(true)); + if (component.isRight()) { + log.debug("Failed to fetch light element for {} error {}", vertexComponent.getUniqueId(), component.right().value()); + return Either.right(component.right().value()); + } else { + result.add(component.left().value()); + } + } + } + } + return Either.left(result); + } + + public Either, StorageOperationStatus> getElementCatalogData(boolean isCatalog, List excludeTypes) { + StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + + Map existInCatalog = new HashMap<>(); + Either, JanusGraphOperationStatus> verticesEither = janusGraphDao.getCatalogOrArchiveVerticies(isCatalog); + if (verticesEither.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(verticesEither.right().value())); + } + Iterator vertices = verticesEither.left().value(); + while (vertices.hasNext()) { + handleCatalogComponent(existInCatalog, vertices.next(), excludeTypes); + } + stopWatch.stop(); + String timeToFetchElements = stopWatch.prettyPrint(); + log.info("time to fetch all catalog elements: {}", timeToFetchElements); + return Either.left(existInCatalog.values().stream().collect(Collectors.toList())); + } + + private void handleCatalogComponent(Map existInCatalog, Vertex vertex, List excludeTypes) { + VertexProperty property = vertex.property(GraphPropertiesDictionary.METADATA.getProperty()); + String json = (String) property.value(); + Map metadatObj = JsonParserUtils.toMap(json); + + String uniqueId = (String) metadatObj.get(JsonPresentationFields.UNIQUE_ID.getPresentation()); + Boolean isDeleted = (Boolean) metadatObj.get(JsonPresentationFields.IS_DELETED.getPresentation()); + + + if (isAddToCatalog(excludeTypes, metadatObj) && (existInCatalog.get(uniqueId) == null && (isDeleted == null || !isDeleted.booleanValue()))) { + CatalogComponent catalogComponent = new CatalogComponent(); + catalogComponent.setUniqueId(uniqueId); + + catalogComponent.setComponentType(ComponentTypeEnum.valueOf((String) metadatObj.get(JsonPresentationFields.COMPONENT_TYPE.getPresentation()))); + catalogComponent.setVersion((String) metadatObj.get(JsonPresentationFields.VERSION.getPresentation())); + catalogComponent.setName((String) metadatObj.get(JsonPresentationFields.NAME.getPresentation())); + catalogComponent.setIcon((String) metadatObj.get(JsonPresentationFields.ICON.getPresentation())); + catalogComponent.setLifecycleState((String) metadatObj.get(JsonPresentationFields.LIFECYCLE_STATE.getPresentation())); + catalogComponent.setLastUpdateDate((Long) metadatObj.get(JsonPresentationFields.LAST_UPDATE_DATE.getPresentation())); + catalogComponent.setDistributionStatus((String) metadatObj.get(JsonPresentationFields.DISTRIBUTION_STATUS.getPresentation())); + Object resourceType = metadatObj.get(JsonPresentationFields.RESOURCE_TYPE.getPresentation()); + if (resourceType != null) { + catalogComponent.setResourceType((String) resourceType); + } + + if (catalogComponent.getComponentType() == ComponentTypeEnum.SERVICE) { + setServiceCategoryFromGraphV(vertex, catalogComponent); + + } else { + setResourceCategoryFromGraphV(vertex, catalogComponent); + } + List tags = (List) metadatObj.get(JsonPresentationFields.TAGS.getPresentation()); + if (tags != null) { + catalogComponent.setTags(tags); + } + existInCatalog.put(uniqueId, catalogComponent); + } + } + + private boolean isAddToCatalog(List excludeTypes, Map metadatObj) { + boolean isAddToCatalog = true; + Object resourceTypeStr = metadatObj.get(JsonPresentationFields.RESOURCE_TYPE.getPresentation()); + if (resourceTypeStr != null) { + ResourceTypeEnum resourceType = ResourceTypeEnum.getType((String) resourceTypeStr); + if (!CollectionUtils.isEmpty(excludeTypes)) { + Optional op = excludeTypes.stream().filter(rt -> rt == resourceType).findAny(); + if (op.isPresent()) + isAddToCatalog = false; + } + } + return isAddToCatalog; + } + + public Either, JanusGraphOperationStatus> getListOfHighestComponents(ComponentTypeEnum + componentType, List excludeTypes, JsonParseFlagEnum parseFlag) { + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesHasNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + if (componentType == ComponentTypeEnum.RESOURCE) { + propertiesToMatch.put(GraphPropertyEnum.IS_ABSTRACT, false); + propertiesHasNotToMatch.put(GraphPropertyEnum.RESOURCE_TYPE, excludeTypes); + } + propertiesHasNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + propertiesHasNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 + + return janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesHasNotToMatch, parseFlag); + } + + // highest + (certified && !highest) + public Either, JanusGraphOperationStatus> getListOfHighestAndAllCertifiedComponents + (ComponentTypeEnum componentType, List excludeTypes) { + long startFetchAllStates = System.currentTimeMillis(); + Either, JanusGraphOperationStatus> highestNodes = getListOfHighestComponents(componentType, excludeTypes, JsonParseFlagEnum.ParseMetadata); + + Map propertiesToMatchCertified = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesHasNotToMatchCertified = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatchCertified.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + propertiesToMatchCertified.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + if (componentType == ComponentTypeEnum.RESOURCE) { + propertiesToMatchCertified.put(GraphPropertyEnum.IS_ABSTRACT, false); + propertiesHasNotToMatchCertified.put(GraphPropertyEnum.RESOURCE_TYPE, excludeTypes); + } + + propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_DELETED, true); + propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 + propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + Either, JanusGraphOperationStatus> certifiedNotHighestNodes = janusGraphDao + .getByCriteria(null, propertiesToMatchCertified, propertiesHasNotToMatchCertified, JsonParseFlagEnum.ParseMetadata); + if (certifiedNotHighestNodes.isRight() && certifiedNotHighestNodes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return Either.right(certifiedNotHighestNodes.right().value()); + } + + long endFetchAllStates = System.currentTimeMillis(); + + List allNodes = new ArrayList<>(); + + if (certifiedNotHighestNodes.isLeft()) { + allNodes.addAll(certifiedNotHighestNodes.left().value()); + } + if (highestNodes.isLeft()) { + allNodes.addAll(highestNodes.left().value()); + } + + log.debug("Fetch catalog {}s all states from graph took {} ms", componentType, endFetchAllStates - startFetchAllStates); + return Either.left(allNodes); + } + + protected Either, StorageOperationStatus> getAllComponentsMarkedForDeletion(ComponentTypeEnum + componentType) { + + // get all components marked for delete + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.IS_DELETED, true); + props.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + + Either, JanusGraphOperationStatus> componentsToDelete = janusGraphDao + .getByCriteria(null, props, JsonParseFlagEnum.NoParse); + + if (componentsToDelete.isRight()) { + JanusGraphOperationStatus error = componentsToDelete.right().value(); + if (error.equals(JanusGraphOperationStatus.NOT_FOUND)) { + log.trace("no components to delete"); + return Either.left(new ArrayList<>()); + } else { + log.info("failed to find components to delete. error : {}", error.name()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); + } + } + return Either.left(componentsToDelete.left().value()); + } + + protected JanusGraphOperationStatus setAdditionalInformationFromGraph(GraphVertex componentV, ToscaElement + toscaElement) { + Either, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ADDITIONAL_INFORMATION); + if (result.isLeft()) { + toscaElement.setAdditionalInformation(result.left().value()); + } else { + if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + return result.right().value(); + } + } + return JanusGraphOperationStatus.OK; + } + + // -------------------------------------------- + public abstract Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView); + + public abstract Either getToscaElement(GraphVertex toscaElementVertex, ComponentParametersView componentParametersView); + + public abstract Either deleteToscaElement(GraphVertex toscaElementVertex); + + public abstract Either createToscaElement(ToscaElement toscaElement); + + protected abstract JanusGraphOperationStatus + setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement); + + protected abstract JanusGraphOperationStatus + setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement); + + protected abstract JanusGraphOperationStatus + setRequirementsFromGraph(GraphVertex componentV, T toscaElement); + + protected abstract StorageOperationStatus + validateCategories(T toscaElementToUpdate, GraphVertex elementV); + + protected abstract StorageOperationStatus + updateDerived(T toscaElementToUpdate, GraphVertex updateElementV); + + public abstract void fillToscaElementVertexData(GraphVertex elementV, T + toscaElementToUpdate, JsonParseFlagEnum flag); + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java new file mode 100644 index 0000000000..43f3487924 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java @@ -0,0 +1,2792 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.*; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +import org.openecomp.sdc.be.model.operations.StorageException; +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.UniqueIdBuilder; +import org.openecomp.sdc.be.resources.data.ComponentMetadataData; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility; +import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.springframework.beans.factory.annotation.Autowired; + +import java.util.*; +import java.util.Map.Entry; +import java.util.function.BiPredicate; +import java.util.stream.Collectors; + +import static java.util.Objects.requireNonNull; +import static org.apache.commons.collections.CollectionUtils.isEmpty; +import static org.apache.commons.collections.CollectionUtils.isNotEmpty; + + +@org.springframework.stereotype.Component("tosca-operation-facade") +public class ToscaOperationFacade { + + // region - Fields + + private static final String COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch a component with and UniqueId {}, error: {}"; + private static final String FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS = "Failed to find recently added property {} on the resource {}. Status is {}. "; + private static final String FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS = "Failed to get updated resource {}. Status is {}. "; + private static final String FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS = "Failed to add the property {} to the resource {}. Status is {}. "; + private static final String SERVICE = "service"; + private static final String NOT_SUPPORTED_COMPONENT_TYPE = "Not supported component type {}"; + private static final String COMPONENT_CREATED_SUCCESSFULLY = "Component created successfully!!!"; + private static final String COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch component with and unique id {}, error: {}"; + @Autowired + private NodeTypeOperation nodeTypeOperation; + @Autowired + private TopologyTemplateOperation topologyTemplateOperation; + @Autowired + private NodeTemplateOperation nodeTemplateOperation; + @Autowired + private GroupsOperation groupsOperation; + @Autowired + private HealingJanusGraphDao janusGraphDao; + + private static final Logger log = Logger.getLogger(ToscaOperationFacade.class.getName()); + // endregion + + // region - ToscaElement - GetById + public static final String PROXY_SUFFIX = "_proxy"; + + public Either getToscaFullElement(String componentId) { + ComponentParametersView filters = new ComponentParametersView(); + filters.setIgnoreCapabiltyProperties(false); + filters.setIgnoreForwardingPath(false); + return getToscaElement(componentId, filters); + } + + public Either getToscaElement(String componentId) { + + return getToscaElement(componentId, JsonParseFlagEnum.ParseAll); + + } + + public Either getToscaElement(String componentId, ComponentParametersView filters) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, filters.detectParseFlag()); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + return getToscaElementByOperation(getVertexEither.left().value(), filters); + } + + public Either getToscaElement(String componentId, JsonParseFlagEnum parseFlag) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, parseFlag); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + return getToscaElementByOperation(getVertexEither.left().value()); + } + + public Either getToscaElement(GraphVertex componentVertex) { + return getToscaElementByOperation(componentVertex); + } + + public Either validateComponentExists(String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + JanusGraphOperationStatus status = getVertexEither.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + return Either.left(false); + } else { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } + } + return Either.left(true); + } + + public Either findLastCertifiedToscaElementByUUID(T component) { + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.UUID, component.getUUID()); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + Either, JanusGraphOperationStatus> getVertexEither = janusGraphDao + .getByCriteria(ModelConverter.getVertexType(component), props); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + return getToscaElementByOperation(getVertexEither.left().value().get(0)); + } + + // endregion + // region - ToscaElement - GetByOperation + private Either getToscaElementByOperation(GraphVertex componentV) { + return getToscaElementByOperation(componentV, new ComponentParametersView()); + } + + private Either getToscaElementByOperation(GraphVertex componentV, ComponentParametersView filters) { + VertexTypeEnum label = componentV.getLabel(); + + ToscaElementOperation toscaOperation = getToscaElementOperation(componentV); + log.debug("getToscaElementByOperation: toscaOperation={}", toscaOperation.getClass()); + Either toscaElement; + String componentId = componentV.getUniqueId(); + if (toscaOperation != null) { + log.debug("Need to fetch tosca element for id {}", componentId); + toscaElement = toscaOperation.getToscaElement(componentV, filters); + } else { + log.debug("not supported tosca type {} for id {}", label, componentId); + toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); + } + if (toscaElement.isRight()) { + return Either.right(toscaElement.right().value()); + } + return Either.left(ModelConverter.convertFromToscaElement(toscaElement.left().value())); + } + + // endregion + private ToscaElementOperation getToscaElementOperation(GraphVertex componentV) { + VertexTypeEnum label = componentV.getLabel(); + switch (label) { + case NODE_TYPE: + return nodeTypeOperation; + case TOPOLOGY_TEMPLATE: + return topologyTemplateOperation; + default: + return null; + } + } + + public Either createToscaComponent(T resource) { + ToscaElement toscaElement = ModelConverter.convertToToscaElement(resource); + + ToscaElementOperation toscaElementOperation = getToscaElementOperation(resource); + Either createToscaElement = toscaElementOperation.createToscaElement(toscaElement); + if (createToscaElement.isLeft()) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + T dataModel = ModelConverter.convertFromToscaElement(createToscaElement.left().value()); + return Either.left(dataModel); + } + return Either.right(createToscaElement.right().value()); + } + + // region - ToscaElement Delete + public StorageOperationStatus markComponentToDelete(Component componentToDelete) { + + if ((componentToDelete.getIsDeleted() != null) && componentToDelete.getIsDeleted() && !componentToDelete.isHighestVersion()) { + // component already marked for delete + return StorageOperationStatus.OK; + } else { + + Either getResponse = janusGraphDao + .getVertexById(componentToDelete.getUniqueId(), JsonParseFlagEnum.ParseAll); + if (getResponse.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentToDelete.getUniqueId(), getResponse.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getResponse.right().value()); + + } + GraphVertex componentV = getResponse.left().value(); + + // same operation for node type and topology template operations + Either result = nodeTypeOperation.markComponentToDelete(componentV); + if (result.isRight()) { + return result.right().value(); + } + return StorageOperationStatus.OK; + } + } + + public Either deleteToscaComponent(String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (getVertexEither.isRight()) { + log.debug("Couldn't fetch component vertex with and unique id {}, error: {}", componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + Either deleteElement = deleteToscaElement(getVertexEither.left().value()); + if (deleteElement.isRight()) { + log.debug("Failed to delete component with and unique id {}, error: {}", componentId, deleteElement.right().value()); + return Either.right(deleteElement.right().value()); + } + T dataModel = ModelConverter.convertFromToscaElement(deleteElement.left().value()); + + return Either.left(dataModel); + } + + private Either deleteToscaElement(GraphVertex componentV) { + VertexTypeEnum label = componentV.getLabel(); + Either toscaElement; + Object componentId = componentV.getUniqueId(); + switch (label) { + case NODE_TYPE: + log.debug("Need to fetch node type for id {}", componentId); + toscaElement = nodeTypeOperation.deleteToscaElement(componentV); + break; + case TOPOLOGY_TEMPLATE: + log.debug("Need to fetch topology template for id {}", componentId); + toscaElement = topologyTemplateOperation.deleteToscaElement(componentV); + break; + default: + log.debug("not supported tosca type {} for id {}", label, componentId); + toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); + break; + } + return toscaElement; + } + // endregion + + private ToscaElementOperation getToscaElementOperation(Component component) { + return ModelConverter.isAtomicComponent(component) ? nodeTypeOperation : topologyTemplateOperation; + } + + public Either getLatestByToscaResourceName(String toscaResourceName) { + return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); + } + + public Either getFullLatestComponentByToscaResourceName(String toscaResourceName) { + ComponentParametersView fetchAllFilter = new ComponentParametersView(); + fetchAllFilter.setIgnoreForwardingPath(true); + fetchAllFilter.setIgnoreCapabiltyProperties(false); + return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName, JsonParseFlagEnum.ParseAll, fetchAllFilter); + } + + public Either getLatestByName(String resourceName) { + return getLatestByName(GraphPropertyEnum.NAME, resourceName); + + } + + public StorageOperationStatus validateCsarUuidUniqueness(String csarUUID) { + + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); + + Either, JanusGraphOperationStatus> resources = janusGraphDao + .getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); + + if (resources.isRight()) { + if (resources.right().value() == JanusGraphOperationStatus.NOT_FOUND) { + return StorageOperationStatus.OK; + } else { + log.debug("failed to get resources from graph with property name: {}", csarUUID); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resources.right().value()); + } + } + return StorageOperationStatus.ENTITY_ALREADY_EXISTS; + + } + + public Either, StorageOperationStatus> getFollowed(String userId, Set lifecycleStates, Set lastStateStates, ComponentTypeEnum componentType) { + Either, StorageOperationStatus> followedResources; + if (componentType == ComponentTypeEnum.RESOURCE) { + followedResources = nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); + } else { + followedResources = topologyTemplateOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); + } + + Set components = new HashSet<>(); + if (followedResources.isRight() && followedResources.right().value() != StorageOperationStatus.NOT_FOUND) { + return Either.right(followedResources.right().value()); + } + if (followedResources.isLeft()) { + List toscaElements = followedResources.left().value(); + toscaElements.forEach(te -> { + T component = ModelConverter.convertFromToscaElement(te); + components.add(component); + }); + } + return Either.left(components); + } + + public Either getLatestCertifiedNodeTypeByToscaResourceName(String toscaResourceName) { + + return getLatestCertifiedByToscaResourceName(toscaResourceName, VertexTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata); + } + + public Either getLatestCertifiedByToscaResourceName(String toscaResourceName, VertexTypeEnum vertexType, JsonParseFlagEnum parseFlag) { + + Either result = null; + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + Either, JanusGraphOperationStatus> getLatestRes = janusGraphDao + .getByCriteria(vertexType, props, parseFlag); + + if (getLatestRes.isRight()) { + JanusGraphOperationStatus status = getLatestRes.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch {} with name {}. status={} ", vertexType, toscaResourceName, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + List resources = getLatestRes.left().value(); + double version = 0.0; + GraphVertex highestResource = null; + for (GraphVertex resource : resources) { + double resourceVersion = Double.parseDouble((String) resource.getJsonMetadataField(JsonPresentationFields.VERSION)); + if (resourceVersion > version) { + version = resourceVersion; + highestResource = resource; + } + } + result = getToscaFullElement(highestResource.getUniqueId()); + } + return result; + } + + public Either validateToscaResourceNameExists(String templateName) { + Either validateUniquenessRes = validateToscaResourceNameUniqueness(templateName); + if (validateUniquenessRes.isLeft()) { + return Either.left(!validateUniquenessRes.left().value()); + } + return validateUniquenessRes; + } + + public Either dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { + return nodeTemplateOperation.dissociateResourceInstances(componentId, requirementDef); + } + + /** + * Allows to get fulfilled requirement by relation and received predicate + */ + public Either getFulfilledRequirementByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { + return nodeTemplateOperation.getFulfilledRequirementByRelation(componentId, instanceId, relation, predicate); + } + + /** + * Allows to get fulfilled capability by relation and received predicate + */ + public Either getFulfilledCapabilityByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { + return nodeTemplateOperation.getFulfilledCapabilityByRelation(componentId, instanceId, relation, predicate); + } + + public StorageOperationStatus associateResourceInstances(String componentId, List relations) { + Either, StorageOperationStatus> status = nodeTemplateOperation.associateResourceInstances(componentId, relations); + if (status.isRight()) { + return status.right().value(); + } + return StorageOperationStatus.OK; + } + + protected Either validateToscaResourceNameUniqueness(String name) { + + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, name); + + Either, JanusGraphOperationStatus> resources = janusGraphDao + .getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); + + if (resources.isRight() && resources.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("failed to get resources from graph with property name: {}", name); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resources.right().value())); + } + List resourceList = (resources.isLeft() ? resources.left().value() : null); + if (isNotEmpty(resourceList)) { + if (log.isDebugEnabled()) { + StringBuilder builder = new StringBuilder(); + for (GraphVertex resourceData : resourceList) { + builder.append(resourceData.getUniqueId() + "|"); + } + log.debug("resources with property name:{} exists in graph. found {}", name, builder); + } + return Either.left(false); + } else { + log.debug("resources with property name:{} does not exists in graph", name); + return Either.left(true); + } + + } + + // region - Component Update + + public Either overrideComponent(Resource newComponent, Resource oldComponent) { + + copyArtifactsToNewComponent(newComponent, oldComponent); + + Either componentVEither = janusGraphDao + .getVertexById(oldComponent.getUniqueId(), JsonParseFlagEnum.NoParse); + if (componentVEither.isRight()) { + log.debug("Falied to fetch component {} error {}", oldComponent.getUniqueId(), componentVEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(componentVEither.right().value())); + } + GraphVertex componentv = componentVEither.left().value(); + Either parentVertexEither = janusGraphDao + .getParentVertex(componentv, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); + if (parentVertexEither.isRight() && parentVertexEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("Falied to fetch parent version for component {} error {}", oldComponent.getUniqueId(), parentVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentVertexEither.right().value())); + } + + Either deleteToscaComponent = deleteToscaElement(componentv); + if (deleteToscaComponent.isRight()) { + log.debug("Falied to remove old component {} error {}", oldComponent.getUniqueId(), deleteToscaComponent.right().value()); + return Either.right(deleteToscaComponent.right().value()); + } + Either createToscaComponent = createToscaComponent(newComponent); + if (createToscaComponent.isRight()) { + log.debug("Falied to create tosca element component {} error {}", newComponent.getUniqueId(), createToscaComponent.right().value()); + return Either.right(createToscaComponent.right().value()); + } + Resource newElement = createToscaComponent.left().value(); + Either newVersionEither = janusGraphDao + .getVertexById(newElement.getUniqueId(), JsonParseFlagEnum.NoParse); + if (newVersionEither.isRight()) { + log.debug("Falied to fetch new tosca element component {} error {}", newComponent.getUniqueId(), newVersionEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(newVersionEither.right().value())); + } + if (parentVertexEither.isLeft()) { + GraphVertex previousVersionV = parentVertexEither.left().value(); + JanusGraphOperationStatus + createEdge = janusGraphDao + .createEdge(previousVersionV, newVersionEither.left().value(), EdgeLabelEnum.VERSION, null); + if (createEdge != JanusGraphOperationStatus.OK) { + log.debug("Falied to associate to previous version {} new version {} error {}", previousVersionV.getUniqueId(), newVersionEither.right().value(), createEdge); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge)); + } + } + return Either.left(newElement); + } + + void copyArtifactsToNewComponent(Resource newComponent, Resource oldComponent) { + // TODO - check if required + Map toscaArtifacts = oldComponent.getToscaArtifacts(); + if (toscaArtifacts != null && !toscaArtifacts.isEmpty()) { + toscaArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); + } + newComponent.setToscaArtifacts(toscaArtifacts); + + Map artifacts = oldComponent.getArtifacts(); + if (artifacts != null && !artifacts.isEmpty()) { + artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); + } + newComponent.setArtifacts(artifacts); + + Map depArtifacts = oldComponent.getDeploymentArtifacts(); + if (depArtifacts != null && !depArtifacts.isEmpty()) { + depArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); + } + newComponent.setDeploymentArtifacts(depArtifacts); + + newComponent.setGroups(oldComponent.getGroups()); + newComponent.setLastUpdateDate(null); + newComponent.setHighestVersion(true); + } + + public Either updateToscaElement(T componentToUpdate) { + return updateToscaElement(componentToUpdate, new ComponentParametersView()); + } + + public Either updateToscaElement(T componentToUpdate, ComponentParametersView filterResult) { + String componentId = componentToUpdate.getUniqueId(); + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } + GraphVertex elementV = getVertexEither.left().value(); + ToscaElementOperation toscaElementOperation = getToscaElementOperation(elementV); + + ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(componentToUpdate); + Either updateToscaElement = toscaElementOperation.updateToscaElement(toscaElementToUpdate, elementV, filterResult); + if (updateToscaElement.isRight()) { + log.debug("Failed to update tosca element {} error {}", componentId, updateToscaElement.right().value()); + return Either.right(updateToscaElement.right().value()); + } + return Either.left(ModelConverter.convertFromToscaElement(updateToscaElement.left().value())); + } + + private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag) { + return getLatestByName(property, nodeName, parseFlag, new ComponentParametersView()); + } + + private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag, ComponentParametersView filter) { + Either result; + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + + propertiesToMatch.put(property, nodeName); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + Either, JanusGraphOperationStatus> highestResources = janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, parseFlag); + if (highestResources.isRight()) { + JanusGraphOperationStatus status = highestResources.right().value(); + log.debug("failed to find resource with name {}. status={} ", nodeName, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + + List resources = highestResources.left().value(); + double version = 0.0; + GraphVertex highestResource = null; + for (GraphVertex vertex : resources) { + Object versionObj = vertex.getMetadataProperty(GraphPropertyEnum.VERSION); + double resourceVersion = Double.parseDouble((String) versionObj); + if (resourceVersion > version) { + version = resourceVersion; + highestResource = vertex; + } + } + return getToscaElementByOperation(highestResource, filter); + } + + // endregion + // region - Component Get By .. + private Either getLatestByName(GraphPropertyEnum property, String nodeName) { + return getLatestByName(property, nodeName, JsonParseFlagEnum.ParseMetadata); + } + + public Either, StorageOperationStatus> getBySystemName(ComponentTypeEnum componentType, String systemName) { + + Either, StorageOperationStatus> result = null; + Either getComponentRes; + List components = new ArrayList<>(); + List componentVertices; + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + + propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, systemName); + if (componentType != null) + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + Either, JanusGraphOperationStatus> getComponentsRes = janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); + if (getComponentsRes.isRight()) { + JanusGraphOperationStatus status = getComponentsRes.right().value(); + log.debug("Failed to fetch the component with system name {}. Status is {} ", systemName, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + componentVertices = getComponentsRes.left().value(); + for (GraphVertex componentVertex : componentVertices) { + getComponentRes = getToscaElementByOperation(componentVertex); + if (getComponentRes.isRight()) { + log.debug("Failed to get the component {}. Status is {} ", componentVertex.getJsonMetadataField(JsonPresentationFields.NAME), getComponentRes.right().value()); + result = Either.right(getComponentRes.right().value()); + break; + } + T componentBySystemName = getComponentRes.left().value(); + log.debug("Found component, id: {}", componentBySystemName.getUniqueId()); + components.add(componentBySystemName); + } + } + if (result == null) { + result = Either.left(components); + } + return result; + } + + public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version) { + return getComponentByNameAndVersion(componentType, name, version, JsonParseFlagEnum.ParseAll); + } + + public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version, JsonParseFlagEnum parseFlag) { + Either result; + + Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); + Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); + + hasProperties.put(GraphPropertyEnum.NAME, name); + hasProperties.put(GraphPropertyEnum.VERSION, version); + hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); + if (componentType != null) { + hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + } + Either, JanusGraphOperationStatus> getResourceRes = janusGraphDao + .getByCriteria(null, hasProperties, hasNotProperties, parseFlag); + if (getResourceRes.isRight()) { + JanusGraphOperationStatus status = getResourceRes.right().value(); + log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + return getToscaElementByOperation(getResourceRes.left().value().get(0)); + } + + public Either, StorageOperationStatus> getCatalogOrArchiveComponents(boolean isCatalog, List excludeTypes) { + List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) + .collect(Collectors.toList()); + return topologyTemplateOperation.getElementCatalogData(isCatalog, excludedResourceTypes); + } + + // endregion + public Either, StorageOperationStatus> getCatalogComponents(ComponentTypeEnum componentType, List excludeTypes, boolean isHighestVersions) { + List components = new ArrayList<>(); + Either, StorageOperationStatus> catalogDataResult; + List toscaElements = new ArrayList<>(); + List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) + .collect(Collectors.toList()); + + switch (componentType) { + case RESOURCE: + catalogDataResult = nodeTypeOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludedResourceTypes, isHighestVersions); + if (catalogDataResult.isRight()) { + return Either.right(catalogDataResult.right().value()); + } + toscaElements = catalogDataResult.left().value(); + break; + case SERVICE: + if (excludeTypes != null && excludeTypes.contains(OriginTypeEnum.SERVICE)) { + break; + } + catalogDataResult = topologyTemplateOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, isHighestVersions); + if (catalogDataResult.isRight()) { + return Either.right(catalogDataResult.right().value()); + } + toscaElements = catalogDataResult.left().value(); + break; + default: + log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); + return Either.right(StorageOperationStatus.BAD_REQUEST); + } + toscaElements.forEach(te -> { + T component = ModelConverter.convertFromToscaElement(te); + components.add(component); + }); + return Either.left(components); + } + + public Either, StorageOperationStatus> deleteMarkedElements(ComponentTypeEnum componentType) { + Either, StorageOperationStatus> allComponentsMarkedForDeletion; + switch (componentType) { + case RESOURCE: + allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); + break; + case SERVICE: + case PRODUCT: + allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); + break; + default: + log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); + return Either.right(StorageOperationStatus.BAD_REQUEST); + } + if (allComponentsMarkedForDeletion.isRight()) { + return Either.right(allComponentsMarkedForDeletion.right().value()); + } + List allMarked = allComponentsMarkedForDeletion.left().value(); + return Either.left(checkIfInUseAndDelete(allMarked)); + } + + private List checkIfInUseAndDelete(List allMarked) { + final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); + List deleted = new ArrayList<>(); + + for (GraphVertex elementV : allMarked) { + boolean isAllowedToDelete = true; + + for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { + Either belongingEdgeByCriteria = janusGraphDao + .getBelongingEdgeByCriteria(elementV, edgeLabelEnum, null); + if (belongingEdgeByCriteria.isLeft()){ + log.debug("Marked element {} in use. don't delete it", elementV.getUniqueId()); + isAllowedToDelete = false; + break; + } + } + + if (isAllowedToDelete) { + Either deleteToscaElement = deleteToscaElement(elementV); + if (deleteToscaElement.isRight()) { + log.debug("Failed to delete marked element UniqueID {}, Name {}, error {}", elementV.getUniqueId(), elementV.getMetadataProperties().get(GraphPropertyEnum.NAME), deleteToscaElement.right().value()); + continue; + } + deleted.add(elementV.getUniqueId()); + } + } + return deleted; + } + + public Either, StorageOperationStatus> getAllComponentsMarkedForDeletion(ComponentTypeEnum componentType) { + Either, StorageOperationStatus> allComponentsMarkedForDeletion; + switch (componentType) { + case RESOURCE: + allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); + break; + case SERVICE: + case PRODUCT: + allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); + break; + default: + log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); + return Either.right(StorageOperationStatus.BAD_REQUEST); + } + if (allComponentsMarkedForDeletion.isRight()) { + return Either.right(allComponentsMarkedForDeletion.right().value()); + } + return Either.left(allComponentsMarkedForDeletion.left().value().stream().map(GraphVertex::getUniqueId).collect(Collectors.toList())); + } + + // region - Component Update + public Either, StorageOperationStatus> addComponentInstanceToTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance, boolean allowDeleted, User user) { + + Either, StorageOperationStatus> result = null; + Either updateContainerComponentRes = null; + if (StringUtils.isEmpty(componentInstance.getIcon())) { + componentInstance.setIcon(origComponent.getIcon()); + } + String nameToFindForCounter = componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy ? componentInstance.getSourceModelName() + PROXY_SUFFIX : origComponent.getName(); + String nextComponentInstanceCounter = getNextComponentInstanceCounter(containerComponent, nameToFindForCounter); + Either, StorageOperationStatus> addResult = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), + ModelConverter.convertToToscaElement(origComponent), nextComponentInstanceCounter, componentInstance, allowDeleted, user); + + if (addResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the component instance {} to container component {}. ", componentInstance.getName(), containerComponent.getName()); + result = Either.right(addResult.right().value()); + } + if (result == null) { + updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponent.getUniqueId()); + if (updateContainerComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", containerComponent.getName(), componentInstance.getName()); + result = Either.right(updateContainerComponentRes.right().value()); + } + } + if (result == null) { + Component updatedComponent = ModelConverter.convertFromToscaElement(updateContainerComponentRes.left().value()); + String createdInstanceId = addResult.left().value().getRight(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been added to container component {}. ", createdInstanceId, updatedComponent.getName()); + result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); + } + return result; + } + + public StorageOperationStatus associateComponentInstancesToComponent(Component containerComponent, Map resourcesInstancesMap, boolean allowDeleted) { + + StorageOperationStatus result = null; + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to add component instances to component {}", containerComponent.getUniqueId()); + + Either metadataVertex = janusGraphDao + .getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.ParseAll); + if (metadataVertex.isRight()) { + JanusGraphOperationStatus status = metadataVertex.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; + } + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); + } + if (result == null) { + result = nodeTemplateOperation.associateComponentInstancesToComponent(containerComponent, resourcesInstancesMap, metadataVertex.left().value(), allowDeleted); + } + return result; + } + + public Either, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance) { + + Either, StorageOperationStatus> result = null; + + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); + componentInstance.setIcon(origComponent.getIcon()); + Either, StorageOperationStatus> updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), + ModelConverter.convertToToscaElement(origComponent), componentInstance); + if (updateResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); + result = Either.right(updateResult.right().value()); + } + if (result == null) { + Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); + String createdInstanceId = updateResult.left().value().getRight(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata of the component instance {} has been updated to container component {}. ", createdInstanceId, updatedComponent.getName()); + result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); + } + return result; + } + + public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent) { + return updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, new ComponentParametersView()); + } + + public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, ComponentParametersView filter) { + + Either result = null; + + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata belonging to container component {}. ", containerComponent.getName()); + + Either updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), filter); + if (updateResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata belonging to container component {}. ", containerComponent.getName()); + result = Either.right(updateResult.right().value()); + } + if (result == null) { + Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value()); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata has been updated to container component {}. ", updatedComponent.getName()); + result = Either.left(updatedComponent); + } + return result; + } + // endregion + + public Either, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(Component containerComponent, String resourceInstanceId) { + + Either, StorageOperationStatus> result = null; + + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); + + Either, StorageOperationStatus> updateResult = nodeTemplateOperation.deleteComponentInstanceFromTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), resourceInstanceId); + if (updateResult.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); + result = Either.right(updateResult.right().value()); + } + if (result == null) { + Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); + String deletedInstanceId = updateResult.left().value().getRight(); + CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been deleted from container component {}. ", deletedInstanceId, updatedComponent.getName()); + result = Either.left(new ImmutablePair<>(updatedComponent, deletedInstanceId)); + } + return result; + } + + private String getNextComponentInstanceCounter(Component containerComponent, String originResourceName) { + Integer nextCounter = 0; + if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstances())) { + String normalizedName = ValidationUtils.normalizeComponentInstanceName(originResourceName); + Integer maxCounter = getMaxCounterFromNamesAndIds(containerComponent, normalizedName); + if (maxCounter != null) { + nextCounter = maxCounter + 1; + } + } + return nextCounter.toString(); + } + + /** + * @return max counter of component instance Id's, null if not found + */ + private Integer getMaxCounterFromNamesAndIds(Component containerComponent, String normalizedName) { + List countersInNames = containerComponent.getComponentInstances().stream() + .filter(ci -> ci.getNormalizedName() != null && ci.getNormalizedName().startsWith(normalizedName)) + .map(ci -> ci.getNormalizedName().split(normalizedName)[1]) + .collect(Collectors.toList()); + List countersInIds = containerComponent.getComponentInstances().stream() + .filter(ci -> ci.getUniqueId() != null && ci.getUniqueId().contains(normalizedName)) + .map(ci -> ci.getUniqueId().split(normalizedName)[1]) + .collect(Collectors.toList()); + List namesAndIdsList = new ArrayList<>(countersInNames); + namesAndIdsList.addAll(countersInIds); + return getMaxInteger(namesAndIdsList); + } + + private Integer getMaxInteger(List counters) { + Integer maxCounter = 0; + Integer currCounter = null; + for (String counter : counters) { + try { + currCounter = Integer.parseInt(counter); + if (maxCounter < currCounter) { + maxCounter = currCounter; + } + } catch (NumberFormatException e) { + continue; + } + } + return currCounter == null ? null : maxCounter; + } + + public Either associateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { + return nodeTemplateOperation.associateResourceInstances(componentId, requirementDef); + + } + + public Either, StorageOperationStatus> createAndAssociateInputs(Map inputs, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDataDefinition(e.getValue()))); + + StorageOperationStatus status = topologyTemplateOperation.associateInputsToComponent(vertex, inputsMap, componentId); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + List inputsResList = null; + if (inputsMap != null && !inputsMap.isEmpty()) { + inputsResList = inputsMap.values().stream() + .map(InputDefinition::new) + .collect(Collectors.toList()); + } + return Either.left(inputsResList); + } + return Either.right(status); + + } + + public Either, StorageOperationStatus> addInputsToComponent(Map inputs, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDefinition(e.getValue()))); + + StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsMap, JsonPresentationFields.NAME); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + List inputsResList = null; + if (inputsMap != null && !inputsMap.isEmpty()) { + inputsResList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList()); + } + return Either.left(inputsResList); + } + return Either.right(status); + + } + + /** + * Add data types into a Component. + * + * @param dataTypes datatypes to be added. the key should be each name of data type. + * @param componentId unique ID of Component. + * @return list of data types. + */ + public Either, StorageOperationStatus> addDataTypesToComponent(Map dataTypes, String componentId) { + + log.trace("#addDataTypesToComponent - enter, componentId={}", componentId); + + /* get component vertex */ + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + /* not found / error */ + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } + GraphVertex vertex = getVertexEither.left().value(); + log.trace("#addDataTypesToComponent - get vertex ok"); + + // convert DataTypeDefinition to DataTypeDataDefinition + Map dataTypeDataMap = dataTypes.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> convertDataTypeToDataTypeData(e.getValue()))); + + // add datatype(s) to the Component. + // if child vertex does not exist, it will be created. + StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, + EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeDataMap, JsonPresentationFields.NAME); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + List inputsResList = null; + if (!dataTypes.isEmpty()) { + inputsResList = new ArrayList<>(dataTypes.values()); + } + return Either.left(inputsResList); + } + + log.trace("#addDataTypesToComponent - leave"); + return Either.right(status); + } + + private DataTypeDataDefinition convertDataTypeToDataTypeData(DataTypeDefinition dataType) { + DataTypeDataDefinition dataTypeData = new DataTypeDataDefinition(dataType); + if (CollectionUtils.isNotEmpty(dataType.getProperties())) { + List propertyDataList = dataType.getProperties().stream() + .map(PropertyDataDefinition::new).collect(Collectors.toList()); + dataTypeData.setPropertiesData(propertyDataList); + } + + // if "derivedFrom" data_type exists, copy the name to "derivedFromName" + if (dataType.getDerivedFrom() != null && StringUtils.isNotEmpty(dataType.getDerivedFrom().getName())) { + // if names are different, log it + if (!StringUtils.equals(dataTypeData.getDerivedFromName(), dataType.getDerivedFrom().getName())) { + log.debug("#convertDataTypeToDataTypeData - derivedFromName(={}) overwritten by derivedFrom.name(={})", + dataType.getDerivedFromName(), dataType.getDerivedFrom().getName()); + } + dataTypeData.setDerivedFromName(dataType.getDerivedFrom().getName()); + } + + // supply "name" field to toscaPresentationValue in each datatype object for DAO operations + dataTypeData.setToscaPresentationValue(JsonPresentationFields.NAME, dataType.getName()); + return dataTypeData; + } + + + public Either, StorageOperationStatus> getComponentInputs(String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug("Couldn't fetch component with and unique id {}, error: {}", componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + + Either toscaElement = + topologyTemplateOperation.getToscaElement(componentId); + if(toscaElement.isRight()) { + return Either.right(toscaElement.right().value()); + } + + TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement.left().value(); + + Map inputsMap = topologyTemplate.getInputs(); + + List inputs = new ArrayList<>(); + if(MapUtils.isNotEmpty(inputsMap)) { + inputs = + inputsMap.values().stream().map(p -> new InputDefinition(p)).collect(Collectors.toList()); + } + + return Either.left(inputs); + } + + public Either, StorageOperationStatus> updateInputsToComponent(List inputs, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + + GraphVertex vertex = getVertexEither.left().value(); + List inputsAsDataDef = inputs.stream().map(PropertyDataDefinition::new).collect(Collectors.toList()); + + StorageOperationStatus status = topologyTemplateOperation.updateToscaDataOfToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsAsDataDef, JsonPresentationFields.NAME); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + List inputsResList = null; + if (inputsAsDataDef != null && !inputsAsDataDef.isEmpty()) { + inputsResList = inputsAsDataDef.stream().map(InputDefinition::new).collect(Collectors.toList()); + } + return Either.left(inputsResList); + } + return Either.right(status); + + } + + // region - ComponentInstance + public Either>, StorageOperationStatus> associateComponentInstancePropertiesToComponent(Map> instProperties, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map instPropsMap = new HashMap<>(); + if (instProperties != null) { + + MapPropertiesDataDefinition propertiesMap; + for (Entry> entry : instProperties.entrySet()) { + propertiesMap = new MapPropertiesDataDefinition(); + + propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); + + instPropsMap.put(entry.getKey(), propertiesMap); + } + } + + StorageOperationStatus status = topologyTemplateOperation.associateInstPropertiesToComponent(vertex, instPropsMap); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + return Either.left(instProperties); + } + return Either.right(status); + + } + + /** + * saves the instInputs as the updated instance inputs of the component container in DB + */ + public Either>, StorageOperationStatus> updateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { + if (instInputs == null || instInputs.isEmpty()) { + return Either.left(instInputs); + } + StorageOperationStatus status; + for (Entry> inputsPerIntance : instInputs.entrySet()) { + List toscaDataListPerInst = inputsPerIntance.getValue(); + List pathKeysPerInst = new ArrayList<>(); + pathKeysPerInst.add(inputsPerIntance.getKey()); + status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", inputsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_INPUTS, status); + return Either.right(status); + } + } + + return Either.left(instInputs); + } + + /** + * saves the instProps as the updated instance properties of the component container in DB + */ + public Either>, StorageOperationStatus> updateComponentInstancePropsToComponent(Map> instProps, String componentId) { + if (instProps == null || instProps.isEmpty()) { + return Either.left(instProps); + } + StorageOperationStatus status; + for (Entry> propsPerIntance : instProps.entrySet()) { + List toscaDataListPerInst = propsPerIntance.getValue(); + List pathKeysPerInst = new ArrayList<>(); + pathKeysPerInst.add(propsPerIntance.getKey()); + status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", propsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_PROPERTIES, status); + return Either.right(status); + } + } + + return Either.left(instProps); + } + + public Either>, StorageOperationStatus> associateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + GraphVertex vertex = getVertexEither.left().value(); + Map instPropsMap = new HashMap<>(); + if (instInputs != null) { + + MapPropertiesDataDefinition propertiesMap; + for (Entry> entry : instInputs.entrySet()) { + propertiesMap = new MapPropertiesDataDefinition(); + + propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); + + instPropsMap.put(entry.getKey(), propertiesMap); + } + } + + StorageOperationStatus status = topologyTemplateOperation.associateInstInputsToComponent(vertex, instPropsMap); + + if (StorageOperationStatus.OK == status) { + log.debug(COMPONENT_CREATED_SUCCESSFULLY); + return Either.left(instInputs); + } + return Either.right(status); + + } + + public Either>, StorageOperationStatus> addComponentInstanceInputsToComponent(Component containerComponent, Map> instProperties) { + requireNonNull(instProperties); + StorageOperationStatus status; + for (Entry> entry : instProperties.entrySet()) { + List props = entry.getValue(); + String componentInstanceId = entry.getKey(); + if (!isEmpty(props)) { + for (ComponentInstanceInput property : props) { + List componentInstancesInputs = containerComponent.getComponentInstancesInputs().get(componentInstanceId); + Optional instanceProperty = componentInstancesInputs.stream() + .filter(p -> p.getName().equals(property.getName())) + .findAny(); + if (instanceProperty.isPresent()) { + status = updateComponentInstanceInput(containerComponent, componentInstanceId, property); + } else { + status = addComponentInstanceInput(containerComponent, componentInstanceId, property); + } + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update instance input {} for instance {} error {} ", property, componentInstanceId, status); + return Either.right(status); + } else { + log.trace("instance input {} for instance {} updated", property, componentInstanceId); + } + } + } + } + return Either.left(instProperties); + } + + public Either>, StorageOperationStatus> addComponentInstancePropertiesToComponent(Component containerComponent, Map> instProperties) { + requireNonNull(instProperties); + for (Entry> entry : instProperties.entrySet()) { + List props = entry.getValue(); + String componentInstanceId = entry.getKey(); + List originalComponentInstProps = + containerComponent.getComponentInstancesProperties().get(componentInstanceId); + Map> containerComponentCapabilities = containerComponent.getCapabilities(); + + if(isEmpty(props)) { + continue; + } + for (ComponentInstanceProperty property : props) { + StorageOperationStatus status = null; + String propertyParentUniqueId = property.getParentUniqueId(); + Optional + capPropDefinition = getPropertyCapability(propertyParentUniqueId, containerComponent); + if(capPropDefinition.isPresent() && MapUtils.isNotEmpty(containerComponentCapabilities)) { + status = populateAndUpdateInstanceCapProperty(containerComponent, componentInstanceId, + containerComponentCapabilities, property, capPropDefinition.get()); + } + if(status == null) { + status = updateOrAddComponentInstanceProperty(containerComponent, componentInstanceId, + originalComponentInstProps, property); + } + if(status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + } + return Either.left(instProperties); + } + + private StorageOperationStatus populateAndUpdateInstanceCapProperty(Component containerComponent, String componentInstanceId, + Map> containerComponentCapabilities, + ComponentInstanceProperty property, + CapabilityDefinition capabilityDefinition) { + List capabilityDefinitions = containerComponentCapabilities.get(capabilityDefinition.getType()); + if(CollectionUtils.isEmpty(capabilityDefinitions)) { + return null; + } + Optional capDefToGetProp = capabilityDefinitions.stream() + .filter(cap -> cap.getUniqueId().equals(capabilityDefinition.getUniqueId()) && cap.getPath().size() == 1).findAny(); + if(capDefToGetProp.isPresent()) { + return updateInstanceCapabilityProperty(containerComponent, componentInstanceId, property, capDefToGetProp.get()); + } + return null; + } + + private static Optional getPropertyCapability(String propertyParentUniqueId, + Component containerComponent) { + + Map> componentCapabilities = containerComponent.getCapabilities(); + if(MapUtils.isEmpty(componentCapabilities)){ + return Optional.empty(); + } + List capabilityDefinitionList = componentCapabilities.values() + .stream().flatMap(Collection::stream).collect(Collectors.toList()); + if(CollectionUtils.isEmpty(capabilityDefinitionList)){ + return Optional.empty(); + } + return capabilityDefinitionList.stream() + .filter(capabilityDefinition -> capabilityDefinition.getUniqueId().equals(propertyParentUniqueId)) + .findAny(); + } + + private StorageOperationStatus updateOrAddComponentInstanceProperty(Component containerComponent, + String componentInstanceId, List originalComponentInstProps, + ComponentInstanceProperty property) + { + StorageOperationStatus status; + // check if the property already exists or not + Optional instanceProperty = originalComponentInstProps.stream() + .filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny(); + if (instanceProperty.isPresent()) { + status = updateComponentInstanceProperty(containerComponent, componentInstanceId, property); + } else { + status = addComponentInstanceProperty(containerComponent, componentInstanceId, property); + } + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update instance property {} for instance {} error {} ", + property, componentInstanceId, status); + } + return status; + } + + public StorageOperationStatus updateInstanceCapabilityProperty(Component containerComponent, String componentInstanceId, + ComponentInstanceProperty property, + CapabilityDefinition capabilityDefinition) { + Optional fetchedCIOptional = containerComponent.getComponentInstanceById(componentInstanceId); + if(!fetchedCIOptional.isPresent()) { + return StorageOperationStatus.GENERAL_ERROR; + } + Either getComponentRes = + getToscaFullElement(fetchedCIOptional.get().getComponentUid()); + if(getComponentRes.isRight()) { + return StorageOperationStatus.GENERAL_ERROR; + } + Optional componentOptional = isNodeServiceProxy(getComponentRes.left().value()); + String propOwner; + if(!componentOptional.isPresent()) { + propOwner = componentInstanceId; + } else { + propOwner = fetchedCIOptional.get().getSourceModelUid(); + } + StorageOperationStatus status; + StringBuffer sb = new StringBuffer(componentInstanceId); + sb.append(ModelConverter.CAP_PROP_DELIM).append(propOwner).append(ModelConverter.CAP_PROP_DELIM) + .append(capabilityDefinition.getType()).append(ModelConverter.CAP_PROP_DELIM).append(capabilityDefinition.getName()); + String capKey = sb.toString(); + status = updateComponentInstanceCapabiltyProperty(containerComponent, componentInstanceId, capKey, property); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to update instance capability property {} for instance {} error {} ", property, + componentInstanceId, status); + return status; + } + return StorageOperationStatus.OK; + } + + private Optional isNodeServiceProxy(Component component) { + if (component.getComponentType().equals(ComponentTypeEnum.SERVICE)) { + return Optional.empty(); + } + Resource resource = (Resource) component; + ResourceTypeEnum resType = resource.getResourceType(); + if(resType.equals(ResourceTypeEnum.ServiceProxy)) { + return Optional.of(component); + } + return Optional.empty(); + } + + public StorageOperationStatus associateDeploymentArtifactsToInstances(Map> instDeploymentArtifacts, String componentId, User user) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map instArtMap = new HashMap<>(); + if (instDeploymentArtifacts != null) { + + MapArtifactDataDefinition artifactsMap; + for (Entry> entry : instDeploymentArtifacts.entrySet()) { + Map artList = entry.getValue(); + Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + artifactsMap = nodeTemplateOperation.prepareInstDeploymentArtifactPerInstance(artifacts, entry.getKey(), user, NodeTemplateOperation.HEAT_VF_ENV_NAME); + + instArtMap.put(entry.getKey(), artifactsMap); + } + } + + return topologyTemplateOperation.associateInstDeploymentArtifactsToComponent(vertex, instArtMap); + + } + + public StorageOperationStatus associateArtifactsToInstances(Map> instArtifacts, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map instArtMap = new HashMap<>(); + if (instArtifacts != null) { + + MapArtifactDataDefinition artifactsMap; + for (Entry> entry : instArtifacts.entrySet()) { + Map artList = entry.getValue(); + Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + artifactsMap = new MapArtifactDataDefinition(artifacts); + + instArtMap.put(entry.getKey(), artifactsMap); + } + } + + return topologyTemplateOperation.associateInstArtifactsToComponent(vertex, instArtMap); + + } + + public StorageOperationStatus associateInstAttributeToComponentToInstances(Map> instArttributes, String componentId) { + + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); + + } + + GraphVertex vertex = getVertexEither.left().value(); + Map instAttr = new HashMap<>(); + if (instArttributes != null) { + + MapPropertiesDataDefinition attributesMap; + for (Entry> entry : instArttributes.entrySet()) { + attributesMap = new MapPropertiesDataDefinition(); + attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); + instAttr.put(entry.getKey(), attributesMap); + } + } + + return topologyTemplateOperation.associateInstAttributeToComponent(vertex, instAttr); + + } + // endregion + + public StorageOperationStatus associateOrAddCalculatedCapReq(Map>> instCapabilties, Map>> instReg, String componentId) { + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); + + } + + GraphVertex vertex = getVertexEither.left().value(); + + Map calcRequirements = new HashMap<>(); + + Map calcCapabilty = new HashMap<>(); + Map calculatedCapabilitiesProperties = new HashMap<>(); + if (instCapabilties != null) { + for (Entry>> entry : instCapabilties.entrySet()) { + + Map> caps = entry.getValue(); + Map mapToscaDataDefinition = new HashMap<>(); + for (Entry> instCapability : caps.entrySet()) { + mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))); + } + + ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(entry.getKey()); + MapListCapabilityDataDefinition capMap = nodeTemplateOperation.prepareCalculatedCapabiltyForNodeType(mapToscaDataDefinition, componentInstance); + + MapCapabilityProperty mapCapabilityProperty = ModelConverter.convertToMapOfMapCapabiltyProperties(caps, componentInstance.getUniqueId(), true); + + calcCapabilty.put(entry.getKey().getUniqueId(), capMap); + calculatedCapabilitiesProperties.put(entry.getKey().getUniqueId(), mapCapabilityProperty); + } + } + + if (instReg != null) { + for (Entry>> entry : instReg.entrySet()) { + + Map> req = entry.getValue(); + Map mapToscaDataDefinition = new HashMap<>(); + for (Entry> instReq : req.entrySet()) { + mapToscaDataDefinition.put(instReq.getKey(), new ListRequirementDataDefinition(instReq.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList()))); + } + + MapListRequirementDataDefinition capMap = nodeTemplateOperation.prepareCalculatedRequirementForNodeType(mapToscaDataDefinition, new ComponentInstanceDataDefinition(entry.getKey())); + + calcRequirements.put(entry.getKey().getUniqueId(), capMap); + } + } + + return topologyTemplateOperation.associateOrAddCalcCapReqToComponent(vertex, calcRequirements, calcCapabilty, calculatedCapabilitiesProperties); + } + + private Either, StorageOperationStatus> getLatestVersionNonCheckoutServicesMetadataOnly(Map hasProps, Map hasNotProps) { + List services = new ArrayList<>(); + List states = new ArrayList<>(); + // include props + hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + // exclude props + states.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + hasNotProps.put(GraphPropertyEnum.STATE, states); + hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); + hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); + return fetchServicesByCriteria(services, hasProps, hasNotProps); + } + + private Either, StorageOperationStatus> getLatestVersionNotAbstractToscaElementsMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType, VertexTypeEnum vertexType) { + List services = null; + Map hasProps = new EnumMap<>(GraphPropertyEnum.class); + Map hasNotProps = new EnumMap<>(GraphPropertyEnum.class); + fillPropsMap(hasProps, hasNotProps, internalComponentType, componentTypeEnum, isAbstract, vertexType); + Either, JanusGraphOperationStatus> getRes = janusGraphDao + .getByCriteria(vertexType, hasProps, hasNotProps, JsonParseFlagEnum.ParseMetadata); + if (getRes.isRight()) { + if (getRes.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) { + return Either.left(new ArrayList<>()); + } else { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); + } + } + // region -> Fetch non checked-out services + if (internalComponentType != null && internalComponentType.toLowerCase().trim().equals(SERVICE) && VertexTypeEnum.NODE_TYPE == vertexType) { + Either, StorageOperationStatus> result = getLatestVersionNonCheckoutServicesMetadataOnly(new EnumMap<>(GraphPropertyEnum.class), new EnumMap<>(GraphPropertyEnum.class)); + if (result.isRight()) { + log.debug("Failed to fetch services for"); + return Either.right(result.right().value()); + } + services = result.left().value(); + if (log.isTraceEnabled() && isEmpty(services)) + log.trace("No relevant services available"); + } + // endregion + List nonAbstractLatestComponents = new ArrayList<>(); + ComponentParametersView params = new ComponentParametersView(true); + params.setIgnoreAllVersions(false); + for (GraphVertex vertexComponent : getRes.left().value()) { + Either componentRes = topologyTemplateOperation.getLightComponent(vertexComponent, componentTypeEnum, params); + if (componentRes.isRight()) { + log.debug("Failed to fetch light element for {} error {}", vertexComponent.getUniqueId(), componentRes.right().value()); + return Either.right(componentRes.right().value()); + } else { + Component component = ModelConverter.convertFromToscaElement(componentRes.left().value()); + nonAbstractLatestComponents.add(component); + } + } + if (CollectionUtils.isNotEmpty(services)) { + nonAbstractLatestComponents.addAll(services); + } + return Either.left(nonAbstractLatestComponents); + } + + public Either getLatestComponentMetadataByUuid(String componentUuid, JsonParseFlagEnum parseFlag, Boolean isHighest) { + + Either result; + Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); + hasProperties.put(GraphPropertyEnum.UUID, componentUuid); + if (isHighest != null) { + hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); + } + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 + + Either, JanusGraphOperationStatus> getRes = janusGraphDao + .getByCriteria(null, hasProperties, propertiesNotToMatch, parseFlag); + if (getRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); + } else { + List latestVersionList = getRes.left().value().stream().map(ModelConverter::convertToComponentMetadata).collect(Collectors.toList()); + ComponentMetadataData latestVersion = latestVersionList.size() == 1 ? latestVersionList.get(0) + : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getMetadataDataDefinition().getVersion()), Double.parseDouble(c2.getMetadataDataDefinition().getVersion()))).get(); + result = Either.left(latestVersion); + } + return result; + } + + public Either getComponentMetadata(String componentId) { + Either result; + Either getRes = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); + if (getRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); + } else { + ComponentMetadataData componentMetadata = ModelConverter.convertToComponentMetadata(getRes.left().value()); + result = Either.left(componentMetadata); + } + return result; + } + + public Either, StorageOperationStatus> getLatestVersionNotAbstractComponents(boolean isAbstract, ComponentTypeEnum componentTypeEnum, + String internalComponentType, List componentUids) { + + List components = new ArrayList<>(); + if (componentUids == null) { + Either, StorageOperationStatus> componentUidsRes = getComponentUids(isAbstract, componentTypeEnum, internalComponentType); + if (componentUidsRes.isRight()) { + return Either.right(componentUidsRes.right().value()); + } + componentUids = componentUidsRes.left().value(); + } + if (!isEmpty(componentUids)) { + for (String componentUid : componentUids) { + ComponentParametersView componentParametersView = buildComponentViewForNotAbstract(); + if ("vl".equalsIgnoreCase(internalComponentType)) { + componentParametersView.setIgnoreCapabilities(false); + componentParametersView.setIgnoreRequirements(false); + } + Either getToscaElementRes = nodeTemplateOperation.getToscaElementOperation(componentTypeEnum).getLightComponent(componentUid, componentTypeEnum, componentParametersView); + if (getToscaElementRes.isRight()) { + log.debug("Failed to fetch resource for error is {}", getToscaElementRes.right().value()); + return Either.right(getToscaElementRes.right().value()); + } + Component component = ModelConverter.convertFromToscaElement(getToscaElementRes.left().value()); + nullifySomeComponentProperties(component); + components.add(component); + } + } + return Either.left(components); + } + + public void nullifySomeComponentProperties(Component component) { + component.setContactId(null); + component.setCreationDate(null); + component.setCreatorUserId(null); + component.setCreatorFullName(null); + component.setLastUpdateDate(null); + component.setLastUpdaterUserId(null); + component.setLastUpdaterFullName(null); + component.setNormalizedName(null); + } + + private Either, StorageOperationStatus> getComponentUids(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { + + Either, StorageOperationStatus> getToscaElementsRes = getLatestVersionNotAbstractMetadataOnly(isAbstract, componentTypeEnum, internalComponentType); + if (getToscaElementsRes.isRight()) { + return Either.right(getToscaElementsRes.right().value()); + } + List collection = getToscaElementsRes.left().value(); + List componentUids; + if (collection == null) { + componentUids = new ArrayList<>(); + } else { + componentUids = collection.stream() + .map(Component::getUniqueId) + .collect(Collectors.toList()); + } + return Either.left(componentUids); + } + + private ComponentParametersView buildComponentViewForNotAbstract() { + ComponentParametersView componentParametersView = new ComponentParametersView(); + componentParametersView.disableAll(); + componentParametersView.setIgnoreCategories(false); + componentParametersView.setIgnoreAllVersions(false); + return componentParametersView; + } + + public Either validateComponentNameExists(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { + Either result = validateComponentNameUniqueness(name, resourceType, componentType); + if (result.isLeft()) { + result = Either.left(!result.left().value()); + } + return result; + } + + public Either validateComponentNameUniqueness(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { + VertexTypeEnum vertexType = ModelConverter.isAtomicComponent(resourceType) ? VertexTypeEnum.NODE_TYPE : VertexTypeEnum.TOPOLOGY_TEMPLATE; + String normalizedName = ValidationUtils.normaliseComponentName(name); + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.NORMALIZED_NAME, normalizedName); + properties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + + Either, JanusGraphOperationStatus> vertexEither = janusGraphDao + .getByCriteria(vertexType, properties, JsonParseFlagEnum.NoParse); + if (vertexEither.isRight() && vertexEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("failed to get vertex from graph with property normalizedName: {}", normalizedName); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); + } + List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; + if (vertexList != null && !vertexList.isEmpty()) { + return Either.left(false); + } else { + return Either.left(true); + } + } + + private void fillNodeTypePropsMap(Map hasProps, Map hasNotProps, String internalComponentType) { + switch (internalComponentType.toLowerCase()) { + case "vf": + case "cvfc": + hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, Arrays.asList(ResourceTypeEnum.VFCMT.name(), ResourceTypeEnum.Configuration.name())); + break; + case SERVICE: + case "pnf": + case "cr": + hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, Arrays.asList(ResourceTypeEnum.VFC.name(), ResourceTypeEnum.VFCMT.name())); + break; + case "vl": + hasProps.put(GraphPropertyEnum.RESOURCE_TYPE, ResourceTypeEnum.VL.name()); + break; + default: + break; + } + } + + private void fillTopologyTemplatePropsMap(Map hasProps, Map hasNotProps, ComponentTypeEnum componentTypeEnum) { + switch (componentTypeEnum) { + case RESOURCE: + hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + break; + case SERVICE: + hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + break; + default: + break; + } + hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, ResourceTypeEnum.CVFC.name()); + } + + private void fillPropsMap(Map hasProps, Map hasNotProps, String internalComponentType, ComponentTypeEnum componentTypeEnum, boolean isAbstract, VertexTypeEnum internalVertexType) { + hasNotProps.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name()); + + hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); + hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); + hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + if (VertexTypeEnum.NODE_TYPE == internalVertexType) { + hasProps.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); + if (internalComponentType != null) { + fillNodeTypePropsMap(hasProps, hasNotProps, internalComponentType); + } + } else { + fillTopologyTemplatePropsMap(hasProps, hasNotProps, componentTypeEnum); + } + } + + private List getInternalVertexTypes(ComponentTypeEnum componentTypeEnum, String internalComponentType) { + List internalVertexTypes = new ArrayList<>(); + if (ComponentTypeEnum.RESOURCE == componentTypeEnum) { + internalVertexTypes.add(VertexTypeEnum.NODE_TYPE); + } + if (ComponentTypeEnum.SERVICE == componentTypeEnum || SERVICE.equalsIgnoreCase(internalComponentType)) { + internalVertexTypes.add(VertexTypeEnum.TOPOLOGY_TEMPLATE); + } + return internalVertexTypes; + } + + public Either, StorageOperationStatus> getLatestVersionNotAbstractMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { + List internalVertexTypes = getInternalVertexTypes(componentTypeEnum, internalComponentType); + List result = new ArrayList<>(); + for (VertexTypeEnum vertexType : internalVertexTypes) { + Either, StorageOperationStatus> listByVertexType = getLatestVersionNotAbstractToscaElementsMetadataOnly(isAbstract, componentTypeEnum, internalComponentType, vertexType); + if (listByVertexType.isRight()) { + return listByVertexType; + } + result.addAll(listByVertexType.left().value()); + } + return Either.left(result); + + } + + private Either, StorageOperationStatus> getLatestComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + if (additionalPropertiesToMatch != null) { + propertiesToMatch.putAll(additionalPropertiesToMatch); + } + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + return getComponentListByUuid(componentUuid, propertiesToMatch); + } + + public Either getComponentByUuidAndVersion(String componentUuid, String version) { + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + + propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); + propertiesToMatch.put(GraphPropertyEnum.VERSION, version); + + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + Either, JanusGraphOperationStatus> vertexEither = janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); + if (vertexEither.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); + } + + List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; + if (vertexList == null || vertexList.isEmpty() || vertexList.size() > 1) { + return Either.right(StorageOperationStatus.NOT_FOUND); + } + + return getToscaElementByOperation(vertexList.get(0)); + } + + public Either, StorageOperationStatus> getComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + + if (additionalPropertiesToMatch != null) { + propertiesToMatch.putAll(additionalPropertiesToMatch); + } + + propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); + + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 + + Either, JanusGraphOperationStatus> vertexEither = janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); + + if (vertexEither.isRight()) { + log.debug("Couldn't fetch metadata for component with uuid {}, error: {}", componentUuid, vertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); + } + List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; + + if (vertexList == null || vertexList.isEmpty()) { + log.debug("Component with uuid {} was not found", componentUuid); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + + ArrayList latestComponents = new ArrayList<>(); + for (GraphVertex vertex : vertexList) { + Either toscaElementByOperation = getToscaElementByOperation(vertex); + + if (toscaElementByOperation.isRight()) { + log.debug("Could not fetch the following Component by UUID {}", vertex.getUniqueId()); + return Either.right(toscaElementByOperation.right().value()); + } + + latestComponents.add(toscaElementByOperation.left().value()); + } + + if (latestComponents.size() > 1) { + for (Component component : latestComponents) { + if (component.isHighestVersion()) { + LinkedList highestComponent = new LinkedList<>(); + highestComponent.add(component); + return Either.left(highestComponent); + } + } + } + + return Either.left(latestComponents); + } + + public Either getLatestServiceByUuid(String serviceUuid) { + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + return getLatestComponentByUuid(serviceUuid, propertiesToMatch); + } + + public Either getLatestComponentByUuid(String componentUuid) { + return getLatestComponentByUuid(componentUuid, null); + } + + public Either getLatestComponentByUuid(String componentUuid, Map propertiesToMatch) { + + Either, StorageOperationStatus> latestVersionListEither = getLatestComponentListByUuid(componentUuid, propertiesToMatch); + + if (latestVersionListEither.isRight()) { + return Either.right(latestVersionListEither.right().value()); + } + + List latestVersionList = latestVersionListEither.left().value(); + + if (latestVersionList.isEmpty()) { + return Either.right(StorageOperationStatus.NOT_FOUND); + } + Component component = latestVersionList.size() == 1 ? latestVersionList.get(0) : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getVersion()), Double.parseDouble(c2.getVersion()))).get(); + + return Either.left(component); + } + + public Either, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract, Boolean isHighest) { + + List resources = new ArrayList<>(); + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + + propertiesToMatch.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); + if (isHighest != null) { + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); + } + propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + Either, JanusGraphOperationStatus> getResourcesRes = janusGraphDao + .getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); + + if (getResourcesRes.isRight()) { + log.debug("Failed to fetch all certified resources. Status is {}", getResourcesRes.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getResourcesRes.right().value())); + } + List resourceVerticies = getResourcesRes.left().value(); + for (GraphVertex resourceV : resourceVerticies) { + Either getResourceRes = getToscaElement(resourceV); + if (getResourceRes.isRight()) { + return Either.right(getResourceRes.right().value()); + } + resources.add(getResourceRes.left().value()); + } + return Either.left(resources); + } + + public Either getLatestByNameAndVersion(String name, String version, JsonParseFlagEnum parseFlag) { + Either result; + + Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); + Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); + + hasProperties.put(GraphPropertyEnum.NAME, name); + hasProperties.put(GraphPropertyEnum.VERSION, version); + hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + + hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); + + Either, JanusGraphOperationStatus> getResourceRes = janusGraphDao + .getByCriteria(null, hasProperties, hasNotProperties, parseFlag); + if (getResourceRes.isRight()) { + JanusGraphOperationStatus status = getResourceRes.right().value(); + log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + return result; + } + return getToscaElementByOperation(getResourceRes.left().value().get(0)); + } + + public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName) { + return getLatestComponentByCsarOrName(componentType, csarUUID, systemName, JsonParseFlagEnum.ParseAll); + } + + public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName, JsonParseFlagEnum parseFlag) { + Map props = new EnumMap<>(GraphPropertyEnum.class); + Map propsHasNot = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.CSAR_UUID, csarUUID); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + if (componentType != null) { + props.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + } + propsHasNot.put(GraphPropertyEnum.IS_DELETED, true); + + GraphVertex resourceMetadataData = null; + List resourceMetadataDataList = null; + Either, JanusGraphOperationStatus> byCsar = janusGraphDao + .getByCriteria(null, props, propsHasNot, JsonParseFlagEnum.ParseMetadata); + if (byCsar.isRight()) { + if (JanusGraphOperationStatus.NOT_FOUND == byCsar.right().value()) { + // Fix Defect DE256036 + if (StringUtils.isEmpty(systemName)) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + JanusGraphOperationStatus.NOT_FOUND)); + } + + props.clear(); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + props.put(GraphPropertyEnum.SYSTEM_NAME, systemName); + Either, JanusGraphOperationStatus> bySystemname = janusGraphDao + .getByCriteria(null, props, JsonParseFlagEnum.ParseMetadata); + if (bySystemname.isRight()) { + log.debug("getLatestResourceByCsarOrName - Failed to find by system name {} error {} ", systemName, bySystemname.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(bySystemname.right().value())); + } + if (bySystemname.left().value().size() > 2) { + log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) must return only 2 latest version, but was returned - {}", bySystemname.left().value().size()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + resourceMetadataDataList = bySystemname.left().value(); + if (resourceMetadataDataList.size() == 1) { + resourceMetadataData = resourceMetadataDataList.get(0); + } else { + for (GraphVertex curResource : resourceMetadataDataList) { + if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { + resourceMetadataData = curResource; + break; + } + } + } + if (resourceMetadataData == null) { + log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) returned 2 latest CERTIFIED versions"); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + if (resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID) != null && !((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID)).equals(csarUUID)) { + log.debug("getLatestResourceByCsarOrName - same system name {} but different csarUUID. exist {} and new {} ", systemName, resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID), csarUUID); + // correct error will be returned from create flow. with all + // correct audit records!!!!! + return Either.right(StorageOperationStatus.NOT_FOUND); + } + return getToscaElement((String) resourceMetadataData.getUniqueId()); + } + } else { + resourceMetadataDataList = byCsar.left().value(); + if (resourceMetadataDataList.size() > 2) { + log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) must return only 2 latest version, but was returned - {}", byCsar.left().value().size()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + if (resourceMetadataDataList.size() == 1) { + resourceMetadataData = resourceMetadataDataList.get(0); + } else { + for (GraphVertex curResource : resourceMetadataDataList) { + if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { + resourceMetadataData = curResource; + break; + } + } + } + if (resourceMetadataData == null) { + log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) returned 2 latest CERTIFIED versions"); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + return getToscaElement((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.UNIQUE_ID), parseFlag); + } + return null; + } + + public Either validateToscaResourceNameExtends(String templateNameCurrent, String templateNameExtends) { + + String currentTemplateNameChecked = templateNameExtends; + + while (currentTemplateNameChecked != null && !currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) { + Either latestByToscaResourceName = getLatestByToscaResourceName(currentTemplateNameChecked); + + if (latestByToscaResourceName.isRight()) { + return latestByToscaResourceName.right().value() == StorageOperationStatus.NOT_FOUND ? Either.left(false) : Either.right(latestByToscaResourceName.right().value()); + } + + Resource value = latestByToscaResourceName.left().value(); + + if (value.getDerivedFrom() != null) { + currentTemplateNameChecked = value.getDerivedFrom().get(0); + } else { + currentTemplateNameChecked = null; + } + } + + return (currentTemplateNameChecked != null && currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) ? Either.left(true) : Either.left(false); + } + + public Either, StorageOperationStatus> fetchMetaDataByResourceType(String resourceType, ComponentParametersView filterBy) { + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.RESOURCE_TYPE, resourceType); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + Map propsHasNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propsHasNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + Either, JanusGraphOperationStatus> resourcesByTypeEither = janusGraphDao + .getByCriteria(null, props, propsHasNotToMatch, JsonParseFlagEnum.ParseMetadata); + + if (resourcesByTypeEither.isRight()) { + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(resourcesByTypeEither.right().value())); + } + + List vertexList = resourcesByTypeEither.left().value(); + List components = new ArrayList<>(); + + for (GraphVertex vertex : vertexList) { + components.add(getToscaElementByOperation(vertex, filterBy).left().value()); + } + + return Either.left(components); + } + + public void commit() { + janusGraphDao.commit(); + } + + public Either updateDistributionStatus(Service service, User user, DistributionStatusEnum distributionStatus) { + Either updateDistributionStatus = topologyTemplateOperation.updateDistributionStatus(service.getUniqueId(), user, distributionStatus); + if (updateDistributionStatus.isRight()) { + return Either.right(updateDistributionStatus.right().value()); + } + GraphVertex serviceV = updateDistributionStatus.left().value(); + service.setDistributionStatus(distributionStatus); + service.setLastUpdateDate((Long) serviceV.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE)); + return Either.left(service); + } + + public Either updateComponentLastUpdateDateOnGraph(Component component) { + + Either result = null; + GraphVertex serviceVertex; + Either updateRes = null; + Either getRes = janusGraphDao + .getVertexById(component.getUniqueId(), JsonParseFlagEnum.ParseMetadata); + if (getRes.isRight()) { + JanusGraphOperationStatus status = getRes.right().value(); + log.error("Failed to fetch component {}. status is {}", component.getUniqueId(), status); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); + } + if (result == null) { + serviceVertex = getRes.left().value(); + long lastUpdateDate = System.currentTimeMillis(); + serviceVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, lastUpdateDate); + component.setLastUpdateDate(lastUpdateDate); + updateRes = janusGraphDao.updateVertex(serviceVertex); + if (updateRes.isRight()) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateRes.right().value())); + } + } + if (result == null) { + result = Either.left(ModelConverter.convertToComponentMetadata(updateRes.left().value())); + } + return result; + } + + public HealingJanusGraphDao getJanusGraphDao() { + return janusGraphDao; + } + + public Either, StorageOperationStatus> getCertifiedServicesWithDistStatus(Set distStatus) { + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + + return getServicesWithDistStatus(distStatus, propertiesToMatch); + } + + public Either, StorageOperationStatus> getServicesWithDistStatus(Set distStatus, Map additionalPropertiesToMatch) { + + List servicesAll = new ArrayList<>(); + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + + if (additionalPropertiesToMatch != null && !additionalPropertiesToMatch.isEmpty()) { + propertiesToMatch.putAll(additionalPropertiesToMatch); + } + + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + if (distStatus != null && !distStatus.isEmpty()) { + for (DistributionStatusEnum state : distStatus) { + propertiesToMatch.put(GraphPropertyEnum.DISTRIBUTION_STATUS, state.name()); + Either, StorageOperationStatus> fetchServicesByCriteria = fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); + if (fetchServicesByCriteria.isRight()) { + return fetchServicesByCriteria; + } else { + servicesAll = fetchServicesByCriteria.left().value(); + } + } + return Either.left(servicesAll); + } else { + return fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); + } + } + + private Either, StorageOperationStatus> fetchServicesByCriteria(List servicesAll, Map propertiesToMatch, Map propertiesNotToMatch) { + Either, JanusGraphOperationStatus> getRes = janusGraphDao + .getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); + if (getRes.isRight()) { + if (getRes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified services by match properties {} not match properties {} . Status is {}. ", propertiesToMatch, propertiesNotToMatch, getRes.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getRes.right().value())); + } + } else { + for (GraphVertex vertex : getRes.left().value()) { + Either getServiceRes = topologyTemplateOperation.getLightComponent(vertex, ComponentTypeEnum.SERVICE, new ComponentParametersView(true)); + + if (getServiceRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified service {}. Status is {}. ", vertex.getJsonMetadataField(JsonPresentationFields.NAME), getServiceRes.right().value()); + return Either.right(getServiceRes.right().value()); + } else { + servicesAll.add(ModelConverter.convertFromToscaElement(getServiceRes.left().value())); + } + } + } + return Either.left(servicesAll); + } + + public void rollback() { + janusGraphDao.rollback(); + } + + public StorageOperationStatus addDeploymentArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map finalDeploymentArtifacts) { + Map instDeplArtifacts = finalDeploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + + return nodeTemplateOperation.addDeploymentArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); + } + + public StorageOperationStatus addInformationalArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map artifacts) { + StorageOperationStatus status = StorageOperationStatus.OK; + if (MapUtils.isNotEmpty(artifacts)) { + Map instDeplArtifacts = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + status = nodeTemplateOperation.addInformationalArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); + } + return status; + } + + public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) { + return nodeTemplateOperation.generateCustomizationUUIDOnInstance(componentId, instanceId); + } + + public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List groupInstances) { + return nodeTemplateOperation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances); + } + + public Either addPropertyToComponent(String propertyName, + PropertyDefinition newPropertyDefinition, + Component component) { + + Either result = null; + Either getUpdatedComponentRes = null; + newPropertyDefinition.setName(propertyName); + + StorageOperationStatus status = getToscaElementOperation(component) + .addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the component {}. Status is {}. ", propertyName, component.getName(), status); + result = Either.right(status); + } + if (result == null) { + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreProperties(false); + filter.setIgnoreInputs(false); + getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); + if (getUpdatedComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated component {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); + result = Either.right(status); + } + } + if (result == null) { + PropertyDefinition newProperty = null; + List properties = + (getUpdatedComponentRes.left().value()).getProperties(); + if (CollectionUtils.isNotEmpty(properties)) { + Optional propertyOptional = properties.stream().filter( + propertyEntry -> propertyEntry.getName().equals(propertyName)).findAny(); + if (propertyOptional.isPresent()) { + newProperty = propertyOptional.get(); + } + } + if (newProperty == null) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the component {}. Status is {}. ", propertyName, component.getUniqueId(), StorageOperationStatus.NOT_FOUND); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } else { + result = Either.left(newProperty); + } + } + return result; + } + public StorageOperationStatus deletePropertyOfComponent(Component component, String propertyName) { + return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, propertyName, JsonPresentationFields.NAME); + } + + public StorageOperationStatus deleteAttributeOfResource(Component component, String attributeName) { + return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, attributeName, JsonPresentationFields.NAME); + } + + public StorageOperationStatus deleteInputOfResource(Component resource, String inputName) { + return getToscaElementOperation(resource).deleteToscaDataElement(resource.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputName, JsonPresentationFields.NAME); + } + + /** + * Deletes a data type from a component. + * @param component the container which has the data type + * @param dataTypeName the data type name to be deleted + * @return Operation result. + */ + public StorageOperationStatus deleteDataTypeOfComponent(Component component, String dataTypeName) { + return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeName, JsonPresentationFields.NAME); + } + + public Either updatePropertyOfComponent(Component component, + PropertyDefinition newPropertyDefinition) { + + Either getUpdatedComponentRes = null; + Either result = null; + StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getName(), status); + result = Either.right(status); + } + if (result == null) { + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreProperties(false); + getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); + if (getUpdatedComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated resource {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); + result = Either.right(status); + } + } + if (result == null) { + Optional newProperty = (getUpdatedComponentRes.left().value()) + .getProperties().stream().filter(p -> p.getName().equals(newPropertyDefinition.getName())).findAny(); + if (newProperty.isPresent()) { + result = Either.left(newProperty.get()); + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + return result; + } + + + + public Either addAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { + + Either getUpdatedComponentRes = null; + Either result = null; + if (newAttributeDef.getUniqueId() == null || newAttributeDef.getUniqueId().isEmpty()) { + String attUniqueId = UniqueIdBuilder.buildAttributeUid(component.getUniqueId(), newAttributeDef.getName()); + newAttributeDef.setUniqueId(attUniqueId); + } + + StorageOperationStatus status = getToscaElementOperation(component).addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); + result = Either.right(status); + } + if (result == null) { + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreAttributesFrom(false); + getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); + if (getUpdatedComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); + result = Either.right(status); + } + } + if (result == null) { + Optional newAttribute = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); + if (newAttribute.isPresent()) { + result = Either.left(newAttribute.get()); + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + return result; + } + + public Either updateAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { + + Either getUpdatedComponentRes = null; + Either result = null; + StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); + result = Either.right(status); + } + if (result == null) { + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreAttributesFrom(false); + getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); + if (getUpdatedComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); + result = Either.right(status); + } + } + if (result == null) { + Optional newProperty = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); + if (newProperty.isPresent()) { + result = Either.left(newProperty.get()); + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + return result; + } + + public Either updateInputOfComponent(Component component, InputDefinition newInputDefinition) { + + Either getUpdatedComponentRes = null; + Either result = null; + StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, newInputDefinition, JsonPresentationFields.NAME); + if (status != StorageOperationStatus.OK) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the input {} to the component {}. Status is {}. ", newInputDefinition.getName(), component.getName(), status); + result = Either.right(status); + } + if (result == null) { + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreInputs(false); + getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); + if (getUpdatedComponentRes.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); + result = Either.right(status); + } + } + if (result == null) { + Optional updatedInput = getUpdatedComponentRes.left().value().getInputs().stream().filter(p -> p.getName().equals(newInputDefinition.getName())).findAny(); + if (updatedInput.isPresent()) { + result = Either.left(updatedInput.get()); + } else { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently updated inputs {} on the resource {}. Status is {}. ", newInputDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); + result = Either.right(StorageOperationStatus.NOT_FOUND); + } + } + return result; + } + + /** + * method - ename the group instances after referenced container name renamed flow - VF rename -(triggers)-> Group rename + * + * @param containerComponent - container such as service + * @param componentInstance - context component + * @param componentInstanceId - id + * @return - successfull/failed status + **/ + public Either cleanAndAddGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, String componentInstanceId) { + String uniqueId = componentInstance.getUniqueId(); + StorageOperationStatus status = nodeTemplateOperation.deleteToscaDataDeepElementsBlockOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, uniqueId); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete group instances for container {}. error {] ", componentInstanceId, status); + return Either.right(status); + } + if (componentInstance.getGroupInstances() != null) { + status = addGroupInstancesToComponentInstance(containerComponent, componentInstance, componentInstance.getGroupInstances()); + if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add group instances for container {}. error {] ", componentInstanceId, status); + return Either.right(status); + } + } + return Either.left(status); + } + + public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groups, Map> groupInstancesArtifacts) { + return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups, groupInstancesArtifacts); + } + + public Either, StorageOperationStatus> updateGroupsOnComponent(Component component, List updatedGroups) { + return groupsOperation.updateGroups(component, updatedGroups, true); + } + + public Either, StorageOperationStatus> updateGroupInstancesOnComponent(Component component, String instanceId, List updatedGroupInstances) { + return groupsOperation.updateGroupInstances(component, instanceId, updatedGroupInstances); + } + + public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groupInstances) { + return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groupInstances); + } + + public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map deploymentArtifacts) { + return nodeTemplateOperation.addDeploymentArtifactsToComponentInstance(containerComponent, componentInstance, deploymentArtifacts); + } + + public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { + return nodeTemplateOperation.updateComponentInstanceProperty(containerComponent, componentInstanceId, property); + } + + public StorageOperationStatus updateComponentInstanceProperties(Component containerComponent, String componentInstanceId, List properties) { + return nodeTemplateOperation.updateComponentInstanceProperties(containerComponent, componentInstanceId, properties); + } + + + public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { + return nodeTemplateOperation.addComponentInstanceProperty(containerComponent, componentInstanceId, property); + } + + public StorageOperationStatus updateComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ + return nodeTemplateOperation.updateComponentInstanceAttribute(containerComponent, componentInstanceId, property); + } + + public StorageOperationStatus addComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ + return nodeTemplateOperation.addComponentInstanceAttribute(containerComponent, componentInstanceId, property); + } + + public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { + return nodeTemplateOperation.updateComponentInstanceInput(containerComponent, componentInstanceId, property); + } + + public StorageOperationStatus updateComponentInstanceInputs(Component containerComponent, String componentInstanceId, List instanceInputs) { + return nodeTemplateOperation.updateComponentInstanceInputs(containerComponent, componentInstanceId, instanceInputs); + } + + public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { + return nodeTemplateOperation.addComponentInstanceInput(containerComponent, componentInstanceId, property); + } + + public void setNodeTypeOperation(NodeTypeOperation nodeTypeOperation) { + this.nodeTypeOperation = nodeTypeOperation; + } + + public void setTopologyTemplateOperation(TopologyTemplateOperation topologyTemplateOperation) { + this.topologyTemplateOperation = topologyTemplateOperation; + } + + public StorageOperationStatus deleteComponentInstanceInputsFromTopologyTemplate(Component containerComponent, List inputsToDelete) { + return topologyTemplateOperation.deleteToscaDataElements(containerComponent.getUniqueId(), EdgeLabelEnum.INPUTS, inputsToDelete.stream().map(PropertyDataDefinition::getName).collect(Collectors.toList())); + } + + public StorageOperationStatus updateComponentInstanceCapabiltyProperty(Component containerComponent, String componentInstanceUniqueId, String capabilityUniqueId, ComponentInstanceProperty property) { + return nodeTemplateOperation.updateComponentInstanceCapabilityProperty(containerComponent, componentInstanceUniqueId, capabilityUniqueId, property); + } + + public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceUniqueId) { + return convertComponentInstanceProperties(containerComponent, componentInstanceUniqueId) + .map(instanceCapProps -> topologyTemplateOperation.updateComponentInstanceCapabilityProperties(containerComponent, componentInstanceUniqueId, instanceCapProps)) + .orElse(StorageOperationStatus.NOT_FOUND); + } + + public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceUniqueId) { + MapInterfaceDataDefinition mapInterfaceDataDefinition = + convertComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId); + return topologyTemplateOperation + .updateComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId, mapInterfaceDataDefinition); + } + + public StorageOperationStatus updateComponentCalculatedCapabilitiesProperties(Component containerComponent) { + Map mapCapabiltyPropertyMap = + convertComponentCapabilitiesProperties(containerComponent); + return nodeTemplateOperation.overrideComponentCapabilitiesProperties(containerComponent, mapCapabiltyPropertyMap); + } + + public StorageOperationStatus deleteAllCalculatedCapabilitiesRequirements(String topologyTemplateId) { + StorageOperationStatus status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES); + if (status == StorageOperationStatus.OK) { + status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS); + } + if (status == StorageOperationStatus.OK) { + status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES); + } + return status; + } + + public Either shouldUpgradeToLatestDerived(Resource clonedResource) { + String componentId = clonedResource.getUniqueId(); + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + + } + GraphVertex nodeTypeV = getVertexEither.left().value(); + + ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(clonedResource); + + Either shouldUpdateDerivedVersion = nodeTypeOperation.shouldUpdateDerivedVersion(toscaElementToUpdate, nodeTypeV); + if (shouldUpdateDerivedVersion.isRight() && StorageOperationStatus.OK != shouldUpdateDerivedVersion.right().value()) { + log.debug("Failed to update derived version for node type {} derived {}, error: {}", componentId, clonedResource.getDerivedFrom().get(0), shouldUpdateDerivedVersion.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } + if (shouldUpdateDerivedVersion.isLeft()) { + return Either.left(ModelConverter.convertFromToscaElement(shouldUpdateDerivedVersion.left().value())); + } + return Either.left(clonedResource); + } + + /** + * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId + */ + public Either, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityName, String capabilityType, String ownerId) { + return topologyTemplateOperation.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId); + } + + private MapInterfaceDataDefinition convertComponentInstanceInterfaces(Component currComponent, + String componentInstanceId) { + MapInterfaceDataDefinition mapInterfaceDataDefinition = new MapInterfaceDataDefinition(); + List componentInterface = currComponent.getComponentInstancesInterfaces().get(componentInstanceId); + + if(CollectionUtils.isNotEmpty(componentInterface)) { + componentInterface.stream().forEach(interfaceDef -> mapInterfaceDataDefinition.put + (interfaceDef.getUniqueId(), interfaceDef)); + } + + return mapInterfaceDataDefinition; + } + + private Map convertComponentCapabilitiesProperties(Component currComponent) { + Map map = ModelConverter.extractCapabilityPropertiesFromGroups(currComponent.getGroups(), true); + map.putAll(ModelConverter.extractCapabilityProperteisFromInstances(currComponent.getComponentInstances(), true)); + return map; + } + + private Optional convertComponentInstanceProperties(Component component, String instanceId) { + return component.fetchInstanceById(instanceId) + .map(ci -> ModelConverter.convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), instanceId)); + } + + public Either associatePolicyToComponent(String componentId, PolicyDefinition policyDefinition, int counter) { + Either result = null; + Either getVertexEither; + getVertexEither = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); + if (getVertexEither.isRight()) { + log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } else { + if (getVertexEither.left().value().getLabel() != VertexTypeEnum.TOPOLOGY_TEMPLATE) { + log.error("Policy association to component of Tosca type {} is not allowed. ", getVertexEither.left().value().getLabel()); + result = Either.right(StorageOperationStatus.BAD_REQUEST); + } + } + if (result == null) { + StorageOperationStatus status = topologyTemplateOperation.addPolicyToToscaElement(getVertexEither.left().value(), policyDefinition, counter); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + if (result == null) { + result = Either.left(policyDefinition); + } + return result; + } + + public StorageOperationStatus associatePoliciesToComponent(String componentId, List policies) { + log.debug("#associatePoliciesToComponent - associating policies for component {}.", componentId); + return janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata) + .either(containerVertex -> topologyTemplateOperation.addPoliciesToToscaElement(containerVertex, policies), + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); + } + + public Either updatePolicyOfComponent(String componentId, PolicyDefinition policyDefinition) { + Either result = null; + Either getVertexEither; + getVertexEither = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value())); + } + if (result == null) { + StorageOperationStatus status = topologyTemplateOperation.updatePolicyOfToscaElement(getVertexEither.left().value(), policyDefinition); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + } + if (result == null) { + result = Either.left(policyDefinition); + } + return result; + } + + public StorageOperationStatus updatePoliciesOfComponent(String componentId, List policyDefinition) { + log.debug("#updatePoliciesOfComponent - updating policies for component {}", componentId); + return janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) + .right() + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) + .either(containerVertex -> topologyTemplateOperation.updatePoliciesOfToscaElement(containerVertex, policyDefinition), + err -> err); + } + + public StorageOperationStatus removePolicyFromComponent(String componentId, String policyId) { + StorageOperationStatus status = null; + Either getVertexEither = janusGraphDao + .getVertexById(componentId, JsonParseFlagEnum.NoParse); + if (getVertexEither.isRight()) { + log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); + status = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVertexEither.right().value()); + } + if (status == null) { + status = topologyTemplateOperation.removePolicyFromToscaElement(getVertexEither.left().value(), policyId); + } + return status; + } + + public boolean canAddGroups(String componentId) { + GraphVertex vertex = janusGraphDao.getVertexById(componentId) + .left() + .on(this::onJanusGraphError); + return topologyTemplateOperation.hasEdgeOfType(vertex, EdgeLabelEnum.GROUPS); + } + + GraphVertex onJanusGraphError(JanusGraphOperationStatus toe) { + throw new StorageException( + DaoStatusConverter.convertJanusGraphStatusToStorageStatus(toe)); + } + + public void updateNamesOfCalculatedCapabilitiesRequirements(String componentId){ + topologyTemplateOperation + .updateNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); + } + + public void revertNamesOfCalculatedCapabilitiesRequirements(String componentId) { + topologyTemplateOperation + .revertNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); + } + + private TopologyTemplate getTopologyTemplate(String componentId) { + return (TopologyTemplate)topologyTemplateOperation + .getToscaElement(componentId, getFilterComponentWithCapProperties()) + .left() + .on(this::throwStorageException); + } + + private ComponentParametersView getFilterComponentWithCapProperties() { + ComponentParametersView filter = new ComponentParametersView(); + filter.setIgnoreCapabiltyProperties(false); + return filter; + } + + private ToscaElement throwStorageException(StorageOperationStatus status) { + throw new StorageException(status); + } + + public Either isComponentInUse(String componentId) { + final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); + Either vertexById = janusGraphDao.getVertexById(componentId); + if (vertexById.isLeft()) { + for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { + Iterator edgeItr = vertexById.left().value().getVertex().edges(Direction.IN, edgeLabelEnum.name()); + if(edgeItr != null && edgeItr.hasNext()){ + return Either.left(true); + } + } + } + return Either.left(false); + } + + public Either, StorageOperationStatus> getComponentListByInvariantUuid + (String componentInvariantUuid, Map additionalPropertiesToMatch) { + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + if (MapUtils.isNotEmpty(additionalPropertiesToMatch)) { + propertiesToMatch.putAll(additionalPropertiesToMatch); + } + propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, componentInvariantUuid); + + Either, JanusGraphOperationStatus> vertexEither = janusGraphDao + .getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata); + + if (vertexEither.isRight()) { + log.debug("Couldn't fetch metadata for component with type {} and invariantUUId {}, error: {}", componentInvariantUuid, vertexEither.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexEither.right().value())); + } + List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; + + if (vertexList == null || vertexList.isEmpty()) { + log.debug("Component with invariantUUId {} was not found", componentInvariantUuid); + return Either.right(StorageOperationStatus.NOT_FOUND); + } + + ArrayList components = new ArrayList<>(); + for (GraphVertex vertex : vertexList) { + Either toscaElementByOperation = getToscaElementByOperation(vertex); + if (toscaElementByOperation.isRight()) { + log.debug("Could not fetch the following Component by Invariant UUID {}", vertex.getUniqueId()); + return Either.right(toscaElementByOperation.right().value()); + } + components.add(toscaElementByOperation.left().value()); + } + + return Either.left(components); + } + + public Either, StorageOperationStatus> getParentComponents(String componentId) { + List parentComponents = new ArrayList<>(); + final List relationEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF); + Either vertexById = janusGraphDao.getVertexById(componentId); + if (vertexById.isLeft()) { + for (EdgeLabelEnum edgeLabelEnum : relationEdgeLabelEnums) { + Either parentVertexEither = janusGraphDao + .getParentVertex(vertexById.left().value(), edgeLabelEnum, JsonParseFlagEnum.ParseJson); + if(parentVertexEither.isLeft()){ + Either componentEither = getToscaElement(parentVertexEither.left().value().getUniqueId()); + if(componentEither.isLeft()){ + parentComponents.add(componentEither.left().value()); + } + } + } + } + return Either.left(parentComponents); + } + public void updateCapReqPropertiesOwnerId(String componentId) { + topologyTemplateOperation + .updateCapReqPropertiesOwnerId(componentId, getTopologyTemplate(componentId)); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperation.java new file mode 100644 index 0000000000..3596fff3ec --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperation.java @@ -0,0 +1,231 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.ComponentDependency; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.stereotype.Component; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +@Component +public class UpgradeOperation extends BaseOperation { + private static final Logger log = Logger.getLogger(UpgradeOperation.class.getName()); + + public Either, StorageOperationStatus> getComponentDependencies(String componentId) { + Either vertexById = janusGraphDao.getVertexById(componentId); + if (vertexById.isRight()) { + log.debug("Failed to fetch vertex with id {} error {}", componentId, vertexById.right().value()); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexById.right().value())); + } + List dependencies = new ArrayList<>(); + + GraphVertex vertex = vertexById.left().value(); + + StorageOperationStatus status = fillDependenciesByVertex(componentId, dependencies, vertex); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + + GraphVertex vertexToStart = vertex; + Function> getNextElement = vertexP -> janusGraphDao + .getParentVertex(vertexP, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); + status = handleVersionChain(componentId, dependencies, vertex, getNextElement); + if (status != StorageOperationStatus.OK) { + return Either.right(status); + } + vertex = vertexToStart; + getNextElement = vertexP -> janusGraphDao + .getChildVertex(vertexP, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); + status = handleVersionChain(componentId, dependencies, vertex, getNextElement); + + return status == StorageOperationStatus.OK ? Either.left(dependencies) : Either.right(status); + } + + private StorageOperationStatus handleVersionChain(String componentId, List dependencies, GraphVertex vertexToStart, Function> getNextElement) { + + StorageOperationStatus status; + boolean nextInChain = true; + GraphVertex vertex = vertexToStart; + Either nextInChainV; + while (nextInChain) { + nextInChainV = getNextElement.apply(vertex); + if (nextInChainV.isRight()) { + nextInChain = false; + } else { + vertex = nextInChainV.left().value(); + status = fillDependenciesByVertex(componentId, dependencies, vertex); + if (status != StorageOperationStatus.OK) { + return status; + } + } + } + return StorageOperationStatus.OK; + } + + private StorageOperationStatus fillDependenciesByVertex(String componentId, List dependencies, GraphVertex vertex) { + StorageOperationStatus status = StorageOperationStatus.OK; + if ( needToAddToDepenedency(vertex) ) { + ComponentDependency dependency = fillDataFromVertex(vertex, null, null); + + List dependList = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); + for (EdgeLabelEnum label : dependList) { + status = fillDependenciesByLabel(componentId, vertex, dependency, label); + if (status != StorageOperationStatus.OK) { + log.debug("Failed to create dependencies for component {} and label {} status {}", componentId, label, status); + break; + } + } + if (status == StorageOperationStatus.OK) { + dependencies.add(dependency); + } + } + return status; + } + private boolean needToAddToDepenedency(GraphVertex vertex){ + Boolean isDeleted = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_DELETED); + Boolean isArchived = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); + return ( isDeleted == Boolean.TRUE || isArchived == Boolean.TRUE) ? false : true; + } + + private StorageOperationStatus fillDependenciesByLabel(String componentId, GraphVertex vertex, ComponentDependency dependency, EdgeLabelEnum label) { + Either, JanusGraphOperationStatus> parentVertecies = janusGraphDao + .getParentVertecies(vertex, label, JsonParseFlagEnum.ParseAll); + if (parentVertecies.isRight() && parentVertecies.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + log.debug("Failed to fetch parent verticies by label INSTANCE_OF for vertex with id {} error {}", componentId, parentVertecies.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentVertecies.right().value()); + } + if (parentVertecies.isLeft()) { + List existIn = new ArrayList<>( ); + parentVertecies.left().value().forEach(v -> handleHighestVersion(vertex, label, existIn, v) ); + dependency.addDependencies(existIn); + } + return StorageOperationStatus.OK; + } + + private void handleHighestVersion(GraphVertex vertexOrigin, EdgeLabelEnum label, List exisIn, GraphVertex containerVertex) { + Boolean isHighest = (Boolean) containerVertex.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + if ( isHighest && needToAddToDepenedency(containerVertex) ) { + JanusGraphVertex janusGraphVertex = containerVertex.getVertex(); + Iterator edges = janusGraphVertex.edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); + //verify that it is a last version - highest by version number + if ( edges == null || !edges.hasNext() ){ + ComponentDependency container = fillDataFromVertex(containerVertex, vertexOrigin.getUniqueId(), label); + boolean addToDependency = true; + if (label == EdgeLabelEnum.ALLOTTED_OF) { + //in case of not full allotted chain not add to dependency list + addToDependency = findAllottedChain(containerVertex, container); + } + if ( addToDependency ){ + exisIn.add(container); + } + } + } + } + + private boolean findAllottedChain(GraphVertex vertex, ComponentDependency container) { + Either, JanusGraphOperationStatus> parentVertecies = janusGraphDao + .getParentVertecies(vertex, EdgeLabelEnum.INSTANCE_OF, JsonParseFlagEnum.ParseAll); + if (parentVertecies.isLeft()) { + List existIn = new ArrayList<>(); + parentVertecies.left().value().forEach(v -> { + Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + if ( isHighest && needToAddToDepenedency(v) ) { + JanusGraphVertex janusGraphVertex = v.getVertex(); + Iterator edges = janusGraphVertex.edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); + //verify that it is a last version - highest by version number + if ( edges == null || !edges.hasNext() ){ + ComponentDependency parentContainer = fillDataFromVertex(v, vertex.getUniqueId(), EdgeLabelEnum.INSTANCE_OF); + existIn.add(parentContainer); + } + } + }); + if ( !existIn.isEmpty() ){ + container.setDependencies(existIn); + return true; + } + } + return false; + } + + private ComponentDependency fillDataFromVertex(GraphVertex v, String originId, EdgeLabelEnum edgeLabel) { + ComponentDependency container = new ComponentDependency(); + container.setName((String) v.getMetadataProperty(GraphPropertyEnum.NAME)); + container.setVersion((String) v.getMetadataProperty(GraphPropertyEnum.VERSION)); + container.setUniqueId(v.getUniqueId()); + container.setType((String) v.getMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE)); + container.setIcon((String) v.getJsonMetadataField(JsonPresentationFields.ICON)); + container.setState((String) v.getMetadataProperty(GraphPropertyEnum.STATE)); + + if (edgeLabel == EdgeLabelEnum.PROXY_OF || edgeLabel == EdgeLabelEnum.ALLOTTED_OF) { + findInstanceNames(v, originId, edgeLabel, container); + } + return container; + } + + private void findInstanceNames(GraphVertex v, String originId, EdgeLabelEnum edgeLabel, ComponentDependency container) { + Map jsonComposition = (Map) v.getJson(); + CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + JanusGraphVertex vertex = v.getVertex(); + Iterator edges = vertex.edges(Direction.OUT, edgeLabel.name()); + while (edges != null && edges.hasNext()) { + Edge edge = edges.next(); + JanusGraphVertex inVertex = (JanusGraphVertex) edge.inVertex(); + String id = (String) janusGraphDao.getProperty(inVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()); + if (id.equals(originId)) { + List instanceOnEdge = (List) janusGraphDao + .getProperty(edge, EdgePropertyEnum.INSTANCES); + Map componentInstances = compositionDataDefinition.getComponentInstances(); + + if (componentInstances != null) { + List ciNames = componentInstances + .values() + .stream() + .filter(ci -> instanceOnEdge.contains(ci.getUniqueId())) + .map(ComponentInstanceDataDefinition::getName) + .collect(Collectors.toList()); + if (ciNames != null && !ciNames.isEmpty()) { + container.setInstanceNames(ciNames); + break; + } + } + } + } + } + + public List getInstanceIdFromAllottedEdge(String resourceId, String serviceInvariantUUID) { + Either vertexById = janusGraphDao.getVertexById(resourceId); + if ( vertexById.isLeft() ){ + GraphVertex vertexG = vertexById.left().value(); + JanusGraphVertex vertex = vertexG.getVertex(); + Iterator edges = vertex.edges(Direction.OUT, EdgeLabelEnum.ALLOTTED_OF.name()); + while ( edges != null && edges.hasNext() ){ + Edge edge = edges.next(); + JanusGraphVertex inVertex = (JanusGraphVertex)edge.inVertex(); + String vertexInInvUUID = (String) janusGraphDao + .getProperty(inVertex, GraphPropertyEnum.INVARIANT_UUID.getProperty()); + if ( vertexInInvUUID.equals(serviceInvariantUUID) ){ + return (List) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES) ; + } + } + } + return new ArrayList<>(); + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityRequirementNameResolver.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityRequirementNameResolver.java new file mode 100644 index 0000000000..c4b7882e50 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityRequirementNameResolver.java @@ -0,0 +1,394 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.openecomp.sdc.be.config.BeEcompErrorManager; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.utils.ComponentUtilities; +import org.openecomp.sdc.common.log.wrappers.Logger; +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; +import static org.apache.commons.collections.CollectionUtils.isNotEmpty; +import static org.apache.commons.lang3.StringUtils.isBlank; + +public class CapabilityRequirementNameResolver { + + private static final Logger log = Logger.getLogger(CapabilityRequirementNameResolver.class); + private static final String PATH_DELIMITER = "."; + + private CapabilityRequirementNameResolver() { + } + + public static void updateNamesOfCalculatedCapabilitiesRequirements(TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { + Map componentCacheToRepair = new HashMap<>(); + log.debug("#updateNamesOfCalculatedCapabilitiesRequirements"); + updateCalculatedCapabilitiesNames(componentCacheToRepair, toscaElement, ownerId, ownerName, originGetter); + updateCalculatedRequirementsNames(componentCacheToRepair, toscaElement, ownerId, ownerName, originGetter); + updateCalculatedCapabilitiesPropertiesKeys(toscaElement, ownerId); + } + + private static void updateCalculatedCapabilitiesPropertiesKeys(TopologyTemplate toscaElement, String ownerId) { + if (calCapPropertiesExist(toscaElement, ownerId)) { + MapCapabilityProperty newProps = new MapCapabilityProperty(); + toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) + .getMapToscaDataDefinition() + .forEach((k, v) -> updateAndAddCalculatedCapabilitiesProperties(k, v, toscaElement.getCalculatedCapabilities().get(ownerId), newProps)); + if (MapUtils.isNotEmpty(newProps.getMapToscaDataDefinition())) { + toscaElement.getCalculatedCapabilitiesProperties().put(ownerId, newProps); + } + } + } + + private static boolean calCapPropertiesExist(TopologyTemplate toscaElement, String ownerId) { + return toscaElement.getCalculatedCapabilitiesProperties() != null + && toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) != null + && MapUtils.isNotEmpty(toscaElement.getCalculatedCapabilitiesProperties().get(ownerId).getMapToscaDataDefinition()) + && capabilitiesExist(toscaElement, ownerId); + } + + private static void updateCalculatedRequirementsNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { + if (requirementsExist(toscaElement, ownerId)) { + String prefix = ownerName + PATH_DELIMITER; + repairReqNames(componentCacheToRepair, toscaElement, ownerId, originGetter); + toscaElement.getCalculatedRequirements().get(ownerId) + .getMapToscaDataDefinition().values().stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(r -> { + if (isRequiredToRepair(r.getName())) { + BeEcompErrorManager.getInstance() + .logBeComponentMissingError("The empty name of the requirement was found. Id: " + r.getUniqueId() + ", ownerId: " + ownerId + ", ownerName: " + ownerName, + toscaElement.getComponentType().getValue(), toscaElement.getName()); + } + if (ComponentUtilities.isNotUpdatedCapReqName(prefix, r.getName(), r.getPreviousName())) { + if (StringUtils.isNotEmpty(r.getPreviousName())) { + r.setParentName(r.getPreviousName()); + } + r.setPreviousName(r.getName()); + } + r.setName(prefix + r.getPreviousName()); + }); + } + } + + private static boolean requirementsExist(TopologyTemplate toscaElement, String ownerId) { + return toscaElement.getCalculatedRequirements() != null + && toscaElement.getCalculatedRequirements().get(ownerId) != null + && MapUtils.isNotEmpty(toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition()); + } + + private static void updateCalculatedCapabilitiesNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { + if (capabilitiesExist(toscaElement, ownerId)) { + String prefix = ownerName + PATH_DELIMITER; + repairCapNames(componentCacheToRepair, toscaElement, ownerId, originGetter); + toscaElement.getCalculatedCapabilities().get(ownerId) + .getMapToscaDataDefinition().values().stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(c -> { + if (isRequiredToRepair(c.getName())) { + BeEcompErrorManager.getInstance() + .logBeComponentMissingError("The empty name of the capability was found. Id: " + c.getUniqueId() + ", ownerId: " + ownerId + ", ownerName: " + ownerName, + toscaElement.getComponentType().getValue(), toscaElement.getName()); + } + if (ComponentUtilities.isNotUpdatedCapReqName(prefix, c.getName(), c.getPreviousName())) { + if (StringUtils.isNotEmpty(c.getPreviousName())) { + c.setParentName(c.getPreviousName()); + } + c.setPreviousName(c.getName()); + } + c.setName(prefix + c.getPreviousName()); + }); + } + } + + private static boolean capabilitiesExist(TopologyTemplate toscaElement, String ownerId) { + return toscaElement.getCalculatedCapabilities() != null + && toscaElement.getCalculatedCapabilities().get(ownerId) != null + && MapUtils.isNotEmpty(toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition()); + } + + private static void repairCapNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { + log.debug("#repairCapNames"); + boolean emptyNameFound = toscaElement.getCalculatedCapabilities() != null + && toscaElement.getCalculatedCapabilities().get(ownerId) != null + && toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition() != null + && toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition().values() + .stream() + .filter(Objects::nonNull) + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .filter(Objects::nonNull) + .anyMatch(c -> isRequiredToRepair(c.getName())); + + ComponentInstanceDataDefinition instance = toscaElement.getComponentInstances() != null ? + toscaElement.getComponentInstances().get(ownerId) : null; + if (instance != null && emptyNameFound) { + log.debug("#repairCapNames - Going to repair the name of the capability for the owner {}. ", ownerId); + toscaElement.getCalculatedCapabilities().get(ownerId) + .getMapToscaDataDefinition().values() + .stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(c -> repairCapName(componentCacheToRepair, instance, c, originGetter)); + } + } + + private static void repairReqNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { + log.debug("#repairReqNames"); + boolean emptyNameFound = toscaElement.getCalculatedRequirements() != null + && toscaElement.getCalculatedRequirements().get(ownerId) != null + && toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition() != null + && toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition().values() + .stream() + .filter(Objects::nonNull) + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .filter(Objects::nonNull) + .anyMatch(r -> isRequiredToRepair(r.getName())); + + ComponentInstanceDataDefinition instance = toscaElement.getComponentInstances() != null ? + toscaElement.getComponentInstances().get(ownerId) : null; + if (instance != null && emptyNameFound) { + log.debug("#repairReqNames - Going to repair the name of the requirement for the owner {}. ", ownerId); + toscaElement.getCalculatedRequirements().get(ownerId) + .getMapToscaDataDefinition().values() + .stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(r -> repairReqName(componentCacheToRepair, instance, r, originGetter)); + } + } + + private static void repairCapName(Map componentCacheToRepair, ComponentInstanceDataDefinition instance, CapabilityDataDefinition capability, Function originGetter) { + if (isRequiredToRepair(capability.getName())) { + log.debug("#repairTopologyTemplateCapName - Going to build the name for the capability: ", capability.getUniqueId()); + buildSetCapName(componentCacheToRepair, capability, instance, originGetter); + } + } + + private static boolean isRequiredToRepair(String name) { + boolean isRequiredToRepair = StringUtils.isEmpty(name) || name.endsWith(".null") || name.contains(".null."); + if (isRequiredToRepair) { + log.debug("#isRequiredToRepair - The name {} should be repaired. ", name); + } else { + log.debug("#isRequiredToRepair - The name {} should not be repaired. ", name); + } + return isRequiredToRepair; + } + + private static void repairReqName(Map componentCacheToRepair, ComponentInstanceDataDefinition instance, RequirementDataDefinition requirement, Function originGetter) { + if (isRequiredToRepair(requirement.getName())) { + log.debug("#repairTopologyTemplateCapName - Going to build the name for the requirement: ", requirement.getUniqueId()); + buildSetReqName(componentCacheToRepair, requirement, instance, originGetter); + } + } + + private static void updateAndAddCalculatedCapabilitiesProperties(String stringKey, MapPropertiesDataDefinition properties, MapListCapabilityDataDefinition calculatedCapabilities, MapCapabilityProperty newProps) { + String[] key = stringKey.split(ModelConverter.CAP_PROP_DELIM); + String capType = key[key.length - 2]; + String capName = key[key.length - 1]; + Optional foundCapOpt = calculatedCapabilities.getMapToscaDataDefinition().get(capType) + .getListToscaDataDefinition().stream() + .filter(c -> StringUtils.isNotEmpty(c.getPreviousName()) && c.getPreviousName().equals(capName)) + .findFirst(); + foundCapOpt.ifPresent(capabilityDataDefinition -> key[key.length - 1] = capabilityDataDefinition.getName()); + newProps.put(buildCaLCapPropKey(key), properties); + } + + public static void revertNamesOfCalculatedCapabilitiesRequirements(TopologyTemplate toscaElement, String ownerId, Function originGetter) { + Map componentCacheToRepair = new HashMap<>(); + log.debug("#revertNamesOfCalculatedCapabilitiesRequirements"); + revertCalculatedCapabilitiesPropertiesKeys(componentCacheToRepair, toscaElement, ownerId, originGetter); + revertCalculatedCapabilitiesNames(toscaElement, ownerId); + revertCalculatedRequirementsNames(componentCacheToRepair, toscaElement, ownerId, originGetter); + } + + private static void revertCalculatedCapabilitiesPropertiesKeys(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { + repairCapNames(componentCacheToRepair, toscaElement, ownerId, originGetter); + if (calCapPropertiesExist(toscaElement, ownerId)) { + MapCapabilityProperty newProps = new MapCapabilityProperty(); + toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) + .getMapToscaDataDefinition() + .forEach((k, v) -> revertAndAddCalculatedCapabilitiesProperties(k, v, toscaElement.getCalculatedCapabilities().get(ownerId), newProps)); + if (MapUtils.isNotEmpty(newProps.getMapToscaDataDefinition())) { + toscaElement.getCalculatedCapabilitiesProperties().put(ownerId, newProps); + } + } + } + + private static void revertCalculatedRequirementsNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { + repairReqNames(componentCacheToRepair, toscaElement, ownerId, originGetter); + if (requirementsExist(toscaElement, ownerId)) { + toscaElement.getCalculatedRequirements().get(ownerId) + .getMapToscaDataDefinition().values().stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(CapabilityRequirementNameResolver::revertReqNames); + } + } + + private static void revertReqNames(RequirementDataDefinition requirement) { + if (StringUtils.isNotEmpty(requirement.getPreviousName())) { + requirement.setName(requirement.getPreviousName()); + requirement.setPreviousName(requirement.getParentName()); + } + } + + private static void revertCalculatedCapabilitiesNames(TopologyTemplate toscaElement, String ownerId) { + if (capabilitiesExist(toscaElement, ownerId)) { + toscaElement.getCalculatedCapabilities().get(ownerId) + .getMapToscaDataDefinition().values().stream() + .flatMap(l -> l.getListToscaDataDefinition().stream()) + .forEach(CapabilityRequirementNameResolver::revertCapNames); + } + } + + private static void revertCapNames(CapabilityDataDefinition capability) { + if (StringUtils.isNotEmpty(capability.getPreviousName())) { + capability.setName(capability.getPreviousName()); + capability.setPreviousName(capability.getParentName()); + } + } + + private static void revertAndAddCalculatedCapabilitiesProperties(String stringKey, MapPropertiesDataDefinition properties, MapListCapabilityDataDefinition calculatedCapabilities, MapCapabilityProperty newProps) { + String[] key = stringKey.split(ModelConverter.CAP_PROP_DELIM); + String capType = key[key.length - 2]; + String capName = key[key.length - 1]; + Optional foundCapOpt = calculatedCapabilities.getMapToscaDataDefinition().get(capType) + .getListToscaDataDefinition().stream() + .filter(c -> c.getName().equals(capName) && StringUtils.isNotEmpty(c.getPreviousName())) + .findFirst(); + foundCapOpt.ifPresent(capabilityDataDefinition -> key[key.length - 1] = capabilityDataDefinition.getPreviousName()); + newProps.put(buildCaLCapPropKey(key), properties); + } + + private static String buildCaLCapPropKey(String[] keyArray) { + StringBuilder key = new StringBuilder(); + for (int i = 0; i < keyArray.length; ++i) { + key.append(keyArray[i]); + if (i < keyArray.length - 1) { + key.append(ModelConverter.CAP_PROP_DELIM); + } + } + return key.toString(); + } + + private static void buildSetCapName(Map componentsCache, CapabilityDataDefinition capability, ComponentInstanceDataDefinition instance, Function originGetter) { + List reducedPath = capability.getOwnerId() != null ? getReducedPathByOwner(capability.getPath(), capability.getOwnerId()) : getReducedPath(capability.getPath()); + log.debug("reducedPath for ownerId {}, reducedPath {} ", capability.getOwnerId(), reducedPath); + reducedPath.remove(reducedPath.size() - 1); + ToscaElement originComponent = getOriginComponent(componentsCache, instance, originGetter); + String name = isRequiredToRepair(capability.getParentName()) ? + extractNameFromUniqueId(capability.getUniqueId()) : capability.getParentName(); + StringBuilder repairedName = buildSubstitutedName(componentsCache, originComponent, reducedPath, originGetter); + log.debug("#buildSetCapName - The name for the capability was built: {}", repairedName); + + capability.setName(repairedName.append(name).toString()); + if (isRequiredToRepair(capability.getPreviousName())) { + capability.setPreviousName(capability.getName().substring(capability.getName().indexOf(PATH_DELIMITER) + 1)); + } + if (isRequiredToRepair(capability.getParentName())) { + capability.setParentName(name); + } + } + + private static void buildSetReqName(Map componentsCache, RequirementDataDefinition requirement, ComponentInstanceDataDefinition instance, Function originGetter) { + List reducedPath = requirement.getOwnerId() != null ? getReducedPathByOwner(requirement.getPath(), requirement.getOwnerId()) : getReducedPath(requirement.getPath()); + log.debug("reducedPath for ownerId {}, reducedPath {} ", requirement.getOwnerId(), reducedPath); + reducedPath.remove(reducedPath.size() - 1); + ToscaElement originComponent = getOriginComponent(componentsCache, instance, originGetter); + String name = isRequiredToRepair(requirement.getParentName()) ? + extractNameFromUniqueId(requirement.getUniqueId()) : requirement.getParentName(); + + StringBuilder repairedName = buildSubstitutedName(componentsCache, originComponent, reducedPath, originGetter); + log.debug("#buildSetReqName - The name for the capability was built: ", repairedName); + requirement.setName(repairedName.append(name).toString()); + if (isRequiredToRepair(requirement.getPreviousName())) { + requirement.setPreviousName(requirement.getName().substring(requirement.getName().indexOf(PATH_DELIMITER) + 1)); + } + if (isRequiredToRepair(requirement.getParentName())) { + requirement.setParentName(name); + } + } + + private static String extractNameFromUniqueId(String uniqueId) { + String[] uid = uniqueId.split("\\."); + return uid[uid.length - 1]; + } + + private static StringBuilder buildSubstitutedName(Map componentsCache, ToscaElement originComponent, List path, Function originGetter) { + StringBuilder substitutedName = new StringBuilder(); + log.debug("#buildSubstitutedName"); + if (isNotEmpty(path) && isTopologyTemplateNotCvfc(originComponent)) { + log.debug("#buildSubstitutedName"); + List reducedPath = getReducedPath(path); + Collections.reverse(reducedPath); + appendNameRecursively(componentsCache, originComponent, reducedPath.iterator(), substitutedName, originGetter); + } + return substitutedName; + } + + private static boolean isTopologyTemplateNotCvfc(ToscaElement originComponent) { + return originComponent.getToscaType() == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE && originComponent.getResourceType() != ResourceTypeEnum.CVFC; + } + + private static ToscaElement getOriginComponent(Map componentsCache, ComponentInstanceDataDefinition instance, Function originGetter) { + if (componentsCache.containsKey(getActualComponentUid(instance))) { + return componentsCache.get(getActualComponentUid(instance)); + } + ToscaElement origin = originGetter.apply(instance); + componentsCache.put(origin.getUniqueId(), origin); + return origin; + } + + public static String getActualComponentUid(ComponentInstanceDataDefinition instance) { + return instance.getIsProxy() ? instance.getSourceModelUid() : instance.getComponentUid(); + } + + private static List getReducedPath(List path) { + return path.stream().distinct().collect(Collectors.toList()); + } + + private static void appendNameRecursively(Map componentsCache, ToscaElement originComponent, Iterator instanceIdIter, StringBuilder substitutedName, Function originGetter) { + log.debug("#appendNameRecursively"); + if (isTopologyTemplateNotCvfc(originComponent) + && MapUtils.isNotEmpty(((TopologyTemplate) originComponent).getComponentInstances()) && instanceIdIter.hasNext()) { + + String ownerId = instanceIdIter.next(); + Optional instanceOpt = ((TopologyTemplate) originComponent).getComponentInstances().values().stream().filter(i -> i.getUniqueId().equals(ownerId)).findFirst(); + if (instanceOpt.isPresent()) { + substitutedName.append(instanceOpt.get().getNormalizedName()).append(PATH_DELIMITER); + ToscaElement getOriginRes = getOriginComponent(componentsCache, instanceOpt.get(), originGetter); + appendNameRecursively(componentsCache, getOriginRes, instanceIdIter, substitutedName, originGetter); + } else if (MapUtils.isNotEmpty(((TopologyTemplate) originComponent).getGroups())) { + Optional groupOpt = ((TopologyTemplate) originComponent).getGroups().values().stream().filter(g -> g.getUniqueId().equals(ownerId)).findFirst(); + groupOpt.ifPresent(groupDataDefinition -> substitutedName.append(groupDataDefinition.getName()).append(PATH_DELIMITER)); + } else { + log.debug("Failed to find an capability owner with uniqueId {} on a component with uniqueId {}", ownerId, originComponent.getUniqueId()); + } + } + } + + private static List getReducedPathByOwner(List path, String ownerId) { + log.debug("ownerId {}, path {} ", ownerId, path); + if (CollectionUtils.isEmpty(path)) { + log.debug("cannot perform reduce by owner, path to component is empty"); + return path; + } + if (isBlank(ownerId)) { + log.debug("cannot perform reduce by owner, component owner is empty"); + return path; + } + //reduce by owner + Map map = path.stream().collect(Collectors.toMap(it -> dropLast(it, PATH_DELIMITER), Function.identity(), (a, b) -> a.endsWith(ownerId) ? a : b)); + //reduce list&duplicates and preserve order + return path.stream().distinct().filter(it -> map.values().contains(it)).collect(Collectors.toList()); + } + + private static String dropLast(String path, String delimiter) { + if (isBlank(path) || isBlank(delimiter)) { + return path; + } + return path.substring(0, path.lastIndexOf(delimiter)); + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapper.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapper.java new file mode 100644 index 0000000000..cc28ae4f83 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapper.java @@ -0,0 +1,53 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ExternalReferencesOperation; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.stereotype.Component; + +import java.util.Map; +import java.util.Optional; + +/** + * Created by yavivi on 12/02/2018. + */ +@Component +public class IdMapper { + + private static final Logger log = Logger.getLogger(ExternalReferencesOperation.class.getName()); + + public String mapComponentNameToUniqueId(String componentInstanceName, GraphVertex serviceVertex) { + return map(componentInstanceName, serviceVertex, true); + } + + public String mapUniqueIdToComponentNameTo(String compUniqueId, GraphVertex serviceVertex) { + return map(compUniqueId, serviceVertex, false); + } + + private String map(String componentUniqueIdOrName, GraphVertex serviceVertex, boolean fromCompName) { + String result = null; + try { + Map jsonComposition = (Map) serviceVertex.getJson(); + CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + + Optional componentInstanceDataDefinitionOptional = null; + if (fromCompName) { + componentInstanceDataDefinitionOptional = compositionDataDefinition.getComponentInstances().values().stream().filter(c -> c.getNormalizedName().equals(componentUniqueIdOrName)).findAny(); + result = componentInstanceDataDefinitionOptional.get().getUniqueId(); + log.debug("Compponent Instance Unique Id = {}", result); + } else { + componentInstanceDataDefinitionOptional = compositionDataDefinition.getComponentInstances().values().stream().filter(c -> c.getUniqueId().equals(componentUniqueIdOrName)).findAny(); + result = componentInstanceDataDefinitionOptional.get().getNormalizedName(); + log.debug("Compponent Instance Normalized Name = {}", result); + } + + } catch (Exception e) { + log.error("Failed to map UUID or Normalized name of " + componentUniqueIdOrName, e); + } + return result; + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverter.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverter.java new file mode 100644 index 0000000000..cd34ad5c18 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverter.java @@ -0,0 +1,1730 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.T + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang.BooleanUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.builder.ReflectionToStringBuilder; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.resources.data.ComponentMetadataData; +import org.openecomp.sdc.be.resources.data.ProductMetadataData; +import org.openecomp.sdc.be.resources.data.ResourceMetadataData; +import org.openecomp.sdc.be.resources.data.ServiceMetadataData; +import org.openecomp.sdc.common.log.wrappers.Logger; + +import java.util.*; +import java.util.Map.Entry; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class ModelConverter { + public static final String CAP_PROP_DELIM = "#"; + private static final Logger log = Logger.getLogger(ModelConverter.class); + + @SuppressWarnings("unchecked") + public static T convertToToscaElement(Component component) { + if (isAtomicComponent(component)) { + return (T) convertToNodeType(component); + } + return (T) convertToTopologyTemplate(component); + } + + @SuppressWarnings("unchecked") + public static T convertFromToscaElement(ToscaElement toscaElement) { + switch (toscaElement.getComponentType()) { + case RESOURCE: + return (T) convertToResource(toscaElement); + case SERVICE: + case PRODUCT: + return (T) convertToService(toscaElement); + default: + return null; + } + } + + public static boolean isAtomicComponent(Component component) { + ComponentTypeEnum componentType = component.getComponentType(); + if (!componentType.equals(ComponentTypeEnum.RESOURCE)) { + return false; + } + Resource resource = (Resource) component; + ResourceTypeEnum resType = resource.getResourceType(); + return isAtomicComponent(resType); + } + + public static boolean isAtomicComponent(ResourceTypeEnum resourceType) { + if (resourceType == null) { + return false; + } + return resourceType.isAtomicType(); + } + + // ********************************************************** + public static VertexTypeEnum getVertexType(Component component) { + VertexTypeEnum vertexType; + if (isAtomicComponent(component)) { + vertexType = VertexTypeEnum.NODE_TYPE; + } else { + vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE; + } + return vertexType; + } + + public static VertexTypeEnum getVertexType(String resourceTypeName) { + VertexTypeEnum vertexType = null; + ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName); + if (isAtomicComponent(resourceType)) { + vertexType = VertexTypeEnum.NODE_TYPE; + } else { + vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE; + } + return vertexType; + } + + + + private static Service convertToService(ToscaElement toscaElement) { + Service service = new Service(); + convertComponentFields(service, toscaElement); + + convertServiceSpecificFields(toscaElement, service); + + TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; + + convertComponentInstances(topologyTemplate, service); + + convertInputs(topologyTemplate, service); + + convertProperties(topologyTemplate, service); + + convertPolicies(topologyTemplate, service); + + convertProperties(topologyTemplate, service); + + convertPolicies(topologyTemplate, service); + + convertGroups(topologyTemplate, service); + + setCapabilitiesToComponentAndGroups(topologyTemplate, service); + + convertPolicies(topologyTemplate, service); + + convertRelations(topologyTemplate, service); + + convertArtifacts(topologyTemplate, service); + + convertServiceApiArtifacts(topologyTemplate, service); + + convertServicePaths(topologyTemplate, service); + + convertServiceInterfaces(topologyTemplate, service); + + convertDataTypes(topologyTemplate, service); + + convertNodeFiltersComponents(topologyTemplate, service); + setCapabilitiesToComponent(topologyTemplate, service); + setRequirementsToComponent(topologyTemplate, service); + return service; + } + + private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) { + service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE)); + service.setDistributionStatus(DistributionStatusEnum + .findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS))); + service.setEcompGeneratedNaming( + (Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true)); + service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, + StringUtils.EMPTY)); + service.setEnvironmentContext( + (String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT)); + service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY)); + } + + private static Resource convertToResource(ToscaElement toscaElement) { + Resource resource = new Resource(); + convertComponentFields(resource, toscaElement); + + resource.setResourceType(toscaElement.getResourceType()); + if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) { + NodeType nodeType = (NodeType) toscaElement; + resource.setDerivedFrom(nodeType.getDerivedFrom()); + resource.setDerivedList(nodeType.getDerivedList()); + resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); + convertAttributes(nodeType, resource); + convertCapabilities(nodeType, resource); + convertRequirements(nodeType, resource); + convertInterfaces(nodeType, resource); + + } else { + TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; + if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) { + resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID)); + resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION)); + resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM)); + convertInterfaces(topologyTemplate, resource); + + } + convertComponentInstances(topologyTemplate, resource); + convertRelations(topologyTemplate, resource); + convertInputs(topologyTemplate, resource); + convertGroups(topologyTemplate, resource); + setCapabilitiesToComponentAndGroups(topologyTemplate, resource); + convertPolicies(topologyTemplate, resource); + convertNodeFiltersComponents(topologyTemplate, resource); + convertProperties(topologyTemplate, resource); + setCapabilitiesToComponent(topologyTemplate, resource); + setRequirementsToComponent(topologyTemplate, resource); + convertDataTypes(topologyTemplate, resource); + } + convertArtifacts(toscaElement, resource); + convertAdditionalInformation(toscaElement, resource); + + return resource; + } + + private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) { + Map interfaces = toscaElement.getInterfaces(); + Map copy; + if (interfaces != null) { + copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue()))); + } else { + copy = new HashMap<>(); + } + resource.setInterfaces(copy); + } + + private static void convertServiceInterfaces(TopologyTemplate toscaElement, Service service) { + Map interfaces = toscaElement.getInterfaces(); + Map copy; + if (interfaces != null) { + copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue()))); + } else { + copy = new HashMap<>(); + } + service.setInterfaces(copy); + } + + private static void convertAttributes(NodeType nodeType, Resource resource) { + Map attributes = nodeType.getAttributes(); + if (attributes != null) { + List attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList()); + resource.setAttributes(attrs); + } + } + + private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) { + PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition); + attributeDefinition.setParentUniqueId(resourceId); + return attributeDefinition; + } + + private static void convertInterfaces(NodeType nodeType, Resource resource) { + Map interfaceArtifacts = nodeType.getInterfaceArtifacts(); + if (interfaceArtifacts != null) { + Map interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue()))); + resource.setInterfaces(interfaces); + } + } + + /** + * Converts component instances of topology template to component instances of resource + * + * @param topologyTemplate + * @param component + */ + public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) { + + if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) { + + setComponentInstancesAttributesToComponent(topologyTemplate, component); + + setComponentInstancesPropertiesToComponent(topologyTemplate, component); + + setComponentInstancesInputsToComponent(topologyTemplate, component); + + setComponentInstancesToComponent(topologyTemplate, component); + + setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component); + + setComponentInstancesRequirementsToComponent(topologyTemplate, component); + + setComponentInstancesArtifactsToComponent(topologyTemplate, component); + + setComponentInstancesInterfacesToComponent(topologyTemplate, component); + + } + } + + private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) { + Map instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts(); + Map instanceArtifacts = topologyTemplate.getInstanceArtifacts(); + + List instances = component.getComponentInstances(); + if (instDeploymentArtifacts != null && instances != null) { + instDeploymentArtifacts.entrySet().forEach(e -> { + Optional ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst(); + if (ci.isPresent()) { + Map mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition(); + Map deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue()))); + + ci.get().setDeploymentArtifacts(deplArt); + } + }); + } + if (instanceArtifacts != null && instances != null) { + instanceArtifacts.entrySet().forEach(e -> { + Optional ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst(); + if (ci.isPresent()) { + Map mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition(); + Map deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue()))); + + ci.get().setArtifacts(deplArt); + } + }); + } + + } + + public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) { + + if (!CollectionUtils.isEmpty(component.getComponentInstances())) { + + setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate); + + setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate); + + setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate); + + setComponentInstancesToTopologyTemplate(component, topologyTemplate); + + setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate); + } + } + + public static void convertRelations(TopologyTemplate topologyTemplate, Component component) { + Map relations = topologyTemplate.getRelations(); + List componentRelations; + if (relations != null && !relations.isEmpty()) { + componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList()); + + } else { + componentRelations = new ArrayList<>(); + } + component.setComponentInstancesRelations(componentRelations); + + } + + public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) { + RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef(); + requirementCapabilityRelDef.setFromNode(relation.getFromId()); + requirementCapabilityRelDef.setToNode(relation.getToId()); + requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI())); + + CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship(); + RelationshipInfo relationshipPair = getRelationshipInfo(relation); + rel.setRelation(relationshipPair); + requirementCapabilityRelDef.setRelationships(Arrays.asList(rel)); + + return requirementCapabilityRelDef; + } + + /** + * @param relation + * @return + */ + private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) { + RelationshipInfo relationshipPair = new RelationshipInfo(); + + relationshipPair.setId(relation.getUniqueId()); + + relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId()); + relationshipPair.setCapabilityUid(relation.getCapabilityId()); + relationshipPair.setCapability(relation.getCapability()); + + relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId()); + relationshipPair.setRequirementUid(relation.getRequirementId()); + relationshipPair.setRequirement(relation.getRequirement()); + + RelationshipImpl relationship = new RelationshipImpl(); + relationship.setType(relation.getType()); + relationshipPair.setRelationships(relationship); + + return relationshipPair; + } + + + public static List convertRelationToToscaRelation(RequirementCapabilityRelDef relation) { + + List relationsList = new ArrayList<>(); + + List relationship = relation.getRelationships(); + relationship.forEach(p -> { + RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition(); + requirementCapabilityRelDef.setFromId(relation.getFromNode()); + requirementCapabilityRelDef.setToId(relation.getToNode()); + requirementCapabilityRelDef.setUniqueId(p.getRelation().getId()); + requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId()); + requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid()); + requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId()); + requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid()); + requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement()); + requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType()); + requirementCapabilityRelDef.setCapability(p.getRelation().getCapability()); + + relationsList.add(requirementCapabilityRelDef); + }); + + return relationsList; + } + + private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) { + convertTopologyTemplateCapabilities(component, topologyTemplate); + if(componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)){ + topologyTemplate.setCalculatedCapabilities(new HashMap<>()); + topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>()); + } + convertComponentInstancesCapabilities(component, topologyTemplate); + convertGroupsCapabilities(component, topologyTemplate); + } + + private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) { + if(groupsCapabilitiesExist(component)){ + component.getGroups() + .stream() + .filter(g -> MapUtils.isNotEmpty(g.getCapabilities())) + .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId())); + } + } + + private static void convertTopologyTemplateCapabilities(Component component, ToscaElement toscaElement) { + Map> capabilities = component.getCapabilities(); + + Map toscaCapMap = new HashMap<>(); + Map toscaCapPropMap = new HashMap<>(); + + if (MapUtils.isNotEmpty(capabilities )) { + capabilities.forEach((s, caps) -> { + if (CollectionUtils.isNotEmpty(caps)) { + List capList = caps.stream().filter(capabilityDefinition -> capabilityDefinition.getOwnerId() + .equals(component.getUniqueId())).map(CapabilityDataDefinition::new).collect(Collectors.toList()); + + populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList); + } + } + ); + + toscaElement.setCapabilities(toscaCapMap); + toscaElement.setCapabilitiesProperties(toscaCapPropMap); + } + } + private static void populateCapabilityMap(Map toscaCapMap, + Map toscaCapPropMap, + String s, List caps, + List capList) { + ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList); + toscaCapMap.put(s, listCapabilityDataDefinition); + + for (CapabilityDefinition cap : caps) { + List capPrps = cap.getProperties(); + if (CollectionUtils.isNotEmpty(capPrps)) { + MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + for (ComponentInstanceProperty cip : capPrps) { + PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip); + propertyDataDefinition.setParentUniqueId(cap.getUniqueId()); + dataToCreate.put(cip.getName(), propertyDataDefinition); + } + toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate); + } + } + } + + private static void convertTopologyTemplateRequirements(Component component, ToscaElement toscaElement) { + Map> requirements = component.getRequirements(); + + Map toscaReqMap = new HashMap<>(); + + if (MapUtils.isNotEmpty(requirements )) { + requirements.forEach((s, reqs)-> { + if (CollectionUtils.isNotEmpty(reqs)) { + List reqList = reqs.stream().filter(requirementDefinition -> requirementDefinition.getOwnerId() + .equals(component.getUniqueId())).map(RequirementDataDefinition::new).collect(Collectors.toList()); + + ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList); + toscaReqMap.put(s, listRequirementDataDefinition); + } + } + ); + toscaElement.setRequirements(toscaReqMap); + } + } + private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) { + if (componentInstancesCapabilitiesExist(component)) { + component.getComponentInstances() + .stream() + .filter(i -> MapUtils.isNotEmpty(i.getCapabilities())) + .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId())); + } + } + + private static void addCapabilities(TopologyTemplate topologyTemplate, Map> capabilities, String ownerId) { + if (MapUtils.isNotEmpty(capabilities)) { + if (topologyTemplate.getCalculatedCapabilities() == null) { + topologyTemplate.setCalculatedCapabilities(new HashMap<>()); + } + topologyTemplate.getCalculatedCapabilities().put(ownerId, convertToMapListCapabiltyDataDefinition(capabilities)); + if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) { + topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>()); + } + topologyTemplate.getCalculatedCapabilitiesProperties().put(ownerId, convertToMapOfMapCapabiltyProperties(capabilities, ownerId)); + } + } + + private static boolean componentInstancesCapabilitiesExist(Component component) { + return component.getCapabilities() != null && component.getComponentInstances() != null + && component.getComponentInstances() + .stream() + .filter(ci->MapUtils.isNotEmpty(ci.getCapabilities())) + .findFirst() + .isPresent(); + } + private static boolean groupsCapabilitiesExist(Component component) { + return component.getCapabilities() != null && component.getGroups() != null + && component.getGroups() + .stream() + .filter(g->MapUtils.isNotEmpty(g.getCapabilities())) + .findFirst() + .isPresent(); + } + public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map> instCapabilities, String ownerId) { + return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false); + } + + public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map> capabilities, String ownerId, boolean fromCsar) { + + Map toscaCapPropMap = new HashMap<>(); + if(MapUtils.isNotEmpty(capabilities)) + capabilities.forEach((s, caps)-> { + + if (caps != null && !caps.isEmpty()) { + + MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + + for (CapabilityDefinition cap : caps) { + List capPrps = cap.getProperties(); + if (capPrps != null) { + + for (ComponentInstanceProperty cip : capPrps) { + dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip)); + } + // format key of capability properties : + // VF instance in service : instanceId#ownerId#type#capName + // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId + + StringBuilder sb = new StringBuilder(ownerId); + sb.append(CAP_PROP_DELIM); + if (fromCsar) { + sb.append(ownerId); + } else { + sb.append(cap.getOwnerId()); + } + sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName()); + toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate)); + } + } + } + } + ); + return new MapCapabilityProperty(toscaCapPropMap); + } + + private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map> instCapabilities) { + + Map mapToscaDataDefinition = new HashMap<>(); + for (Entry> instCapability : instCapabilities.entrySet()) { + mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))); + } + + return new MapListCapabilityDataDefinition(mapToscaDataDefinition); + } + + private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) { + + convertTopologyTemplateRequirements(component, topologyTemplate); + if (component.getRequirements() != null && component.getComponentInstances() != null) { + topologyTemplate.setCalculatedRequirements(new HashMap<>()); + for (ComponentInstance instance : component.getComponentInstances()) { + Map> instRequirements = instance.getRequirements(); + if (MapUtils.isNotEmpty(instRequirements)) { + if (topologyTemplate.getCalculatedRequirements() == null) { + topologyTemplate.setCalculatedRequirements(new HashMap<>()); + } + topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements)); + } + } + } + } + + private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map> instRequirements) { + + Map mapToscaDataDefinition = new HashMap<>(); + for (Entry> instRequirement : instRequirements.entrySet()) { + mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList()))); + } + + return new MapListRequirementDataDefinition(mapToscaDataDefinition); + } + + @SuppressWarnings("unchecked") + private static void convertComponentFields(Component component, ToscaElement toscaElement) { + component.setName(toscaElement.getName()); + component.setAllVersions(toscaElement.getAllVersions()); + component.setCategories(toscaElement.getCategories()); + component.setComponentType(toscaElement.getComponentType()); + component.setCreationDate(toscaElement.getCreationDate()); + component.setCreatorUserId(toscaElement.getCreatorUserId()); + component.setCreatorFullName(toscaElement.getCreatorFullName()); + component.setLastUpdateDate(toscaElement.getLastUpdateDate()); + component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName()); + component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId()); + component.setNormalizedName(toscaElement.getNormalizedName()); + + component.setLifecycleState(toscaElement.getLifecycleState()); + component.setVersion(toscaElement.getVersion()); + component.setHighestVersion(toscaElement.isHighestVersion()); + component.setUniqueId(toscaElement.getUniqueId()); + component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME)); + component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType()); + component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion()); + + Map properties = toscaElement.getProperties(); + if(MapUtils.isNotEmpty(properties)) { + List propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList()); + component.setProperties(propertiesMap); + } + + //archive + component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived()); + + + //component.setArchiveTime(toscaElement.getArchiveTime() == null ? 0L : toscaElement.getArchiveTime()); + component.setArchiveTime(toscaElement.getArchiveTime()); + component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived()); + + if (component.getComponentType() == ComponentTypeEnum.RESOURCE) { + Resource resource = (Resource) component; + resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); + resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); + resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME)); + resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE)); + // field isn't mandatory , but shouldn't be null(should be an empty string instead) + if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){ + resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)); + } else { + resource.setResourceVendorModelNumber(""); + } + } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) { + Service service = (Service) component; + if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){ + service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)); + } else { + service.setServiceType(""); + } + if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){ + service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)); + } else { + service.setServiceRole(""); + } + } + component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL)); + component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON)); + component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION)); + component.setTags((List) toscaElement.getMetadataValue(JsonPresentationFields.TAGS)); + component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID)); + component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID)); + component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID)); + component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED)); + component.setToscaType(toscaElement.getToscaType().getValue()); + } + + private static NodeType convertToNodeType(Component component) { + Resource resource = (Resource) component; + NodeType nodeType = new NodeType(); + nodeType.setDerivedFrom(resource.getDerivedFrom()); + nodeType.setDerivedList(resource.getDerivedList()); + nodeType.setResourceType(resource.getResourceType()); + convertCommonToscaData(component, nodeType); + convertAdditionalInformation(component, nodeType); + convertArtifacts(resource, nodeType); + convertCapabilities(resource, nodeType); + convertRequirements(resource, nodeType); + convertAttributes(resource, nodeType); + convertProperties(resource, nodeType); + convertInterfaces(resource, nodeType); + return nodeType; + } + + private static void convertProperties(Resource resource, NodeType nodeType) { + List properties = resource.getProperties(); + if (properties != null && !properties.isEmpty()) { + Map propertiesMap = properties.stream().collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new)); + nodeType.setProperties(propertiesMap); + } + } + + private static void convertInterfaces(Resource resource, NodeType nodeType) { + Map interfaces = resource.getInterfaces(); + if (interfaces != null) { + Map interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue()))); + nodeType.setInterfaceArtifacts(interfaceArtifacts); + } + } + + private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) { + List additionalInformation = component.getAdditionalInformation(); + if (additionalInformation != null) { + Map addInfo = additionalInformation.stream().collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new)); + toscaElement.setAdditionalInformation(addInfo); + } + } + + private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) { + Map additionalInformation = toscaElement.getAdditionalInformation(); + if (additionalInformation != null) { + List addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new).collect(Collectors.toList()); + resource.setAdditionalInformation(addInfo); + } + } + + private static void convertArtifacts(ToscaElement toscaElement, Component component) { + Map artifacts = toscaElement.getArtifacts(); + Map copy; + if (artifacts != null) { + copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); + + } else { + copy = new HashMap<>(); + } + component.setArtifacts(copy); + + Map toscaArtifacts = toscaElement.getToscaArtifacts(); + if (toscaArtifacts != null) { + copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); + + } else { + copy = new HashMap<>(); + } + component.setToscaArtifacts(copy); + + Map deploymentArtifacts = toscaElement.getDeploymentArtifacts(); + if (deploymentArtifacts != null) { + copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); + + } else { + copy = new HashMap<>(); + } + component.setDeploymentArtifacts(copy); + } + + private static void convertNodeFiltersComponents(TopologyTemplate topologyTemplate, Component component) { + Map filters = topologyTemplate.getNodeFilterComponents(); + Map copy; + if (filters != null) { + copy = filters.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new CINodeFilterDataDefinition(e.getValue()))); + } else { + copy = new HashMap<>(); + } + component.setNodeFilterComponents(copy); + } + + private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) { + Map serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts(); + Map copy; + if (serviceApiArtifacts != null) { + copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); + + } else { + copy = new HashMap<>(); + } + service.setServiceApiArtifacts(copy); + } + private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) { + Map servicePaths = topologyTemplate.getForwardingPaths(); + Map copy; + if (servicePaths != null) { + copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue()))); + + } else { + copy = new HashMap<>(); + } + service.setForwardingPaths(copy); + } + + private static void convertArtifacts(Component component, ToscaElement toscaElement) { + Map artifacts = component.getArtifacts(); + if (artifacts != null) { + Map copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + toscaElement.setArtifacts(copy); + } + + Map toscaArtifacts = component.getToscaArtifacts(); + if (toscaArtifacts != null) { + Map copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + toscaElement.setToscaArtifacts(copy); + } + + Map deploymentArtifacts = component.getDeploymentArtifacts(); + if (deploymentArtifacts != null) { + Map copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + toscaElement.setDeploymentArtifacts(copy); + } + } + + private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) { + Map serviceApiArtifacts = service.getServiceApiArtifacts(); + if (serviceApiArtifacts != null) { + Map copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + topologyTemplate.setServiceApiArtifacts(copy); + } + } + + private static void convertCapabilities(Component component, NodeType toscaElement) { + Map> capabilities = component.getCapabilities(); + + Map toscaCapMap = new HashMap<>(); + Map toscaCapPropMap = new HashMap<>(); + + if (capabilities != null && !capabilities.isEmpty()) { + capabilities.forEach((s, caps) -> { + + if (caps != null && !caps.isEmpty()) { + List capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()); + + populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList); + } + } + ); + + toscaElement.setCapabilities(toscaCapMap); + toscaElement.setCapabilitiesProperties(toscaCapPropMap); + } + } + + private static void convertAttributes(Resource component, NodeType nodeType) { + List attributes = component.getAttributes(); + if (attributes != null) { + Map attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())); + nodeType.setAttributes(attrsByName); + } + } + + private static void convertRequirements(Resource component, NodeType nodeType) { + Map> requirements = component.getRequirements(); + + Map toscaReqMap = new HashMap<>(); + + if (requirements != null && !requirements.isEmpty()) { + requirements.forEach((s, reqs)-> { + + if (reqs != null && !reqs.isEmpty()) { + List reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList()); + + ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList); + toscaReqMap.put(s, listRequirementDataDefinition); + } + } + ); + nodeType.setRequirements(toscaReqMap); + } + } + + private static void convertCapabilities(NodeType toscaElement, Component component) { + Map toscaCapabilities = toscaElement.getCapabilities(); + Map toscaCapPropMap = toscaElement.getCapabilitiesProperties(); + + Map> compCap = new HashMap<>(); + if (toscaCapabilities == null || toscaCapabilities.isEmpty()) + return; + toscaCapabilities.forEach((s, cap)-> { + + if (cap != null) { + List capDataList = cap.getListToscaDataDefinition(); + + if (capDataList != null && !capDataList.isEmpty()) { + List capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList()); + compCap.put(s, capList); + } + } + + } + ); + if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) { + toscaCapPropMap.forEach((s, capProp)-> { + String[] result = s.split(CAP_PROP_DELIM); + if (capProp != null) { + Map capMap = capProp.getMapToscaDataDefinition(); + + if (capMap != null && !capMap.isEmpty()) { + List capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()); + + List cap = compCap.get(result[0]); + Optional op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst(); + if (op.isPresent()) { + op.get().setProperties(capPropsList); + } + } + } + } + ); + } + + component.setCapabilities(compCap); + + } + + private static void convertGroups(TopologyTemplate toscaElement, Component component) { + Map toscaGroups = toscaElement.getGroups(); + List groupDefinitions = null; + if (MapUtils.isNotEmpty(toscaGroups)) { + groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList()); + } + component.setGroups(groupDefinitions); + } + + private static void convertPolicies(TopologyTemplate toscaElement, Component component) { + Map policies = toscaElement.getPolicies(); + Map policyDefinitions = null; + if (MapUtils.isNotEmpty(policies)) { + policyDefinitions = policies.values().stream().map(PolicyDefinition::new).collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity())); + } + component.setPolicies(policyDefinitions); + } + + private static void convertGroups(Component component, TopologyTemplate toscaElement) { + List groupDefinitions = component.getGroups(); + Map groups = new HashMap<>(); + + if (groupDefinitions != null && groups.isEmpty()) { + groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getName, GroupDefinition::new)); + } + toscaElement.setGroups(groups); + } + + private static void convertPolicies(Component component, TopologyTemplate toscaElement) { + Map policyDefinitions = component.getPolicies(); + Map policies = new HashMap<>(); + if (MapUtils.isNotEmpty(policyDefinitions)) { + policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new))); + } + toscaElement.setPolicies(policies); + } + + private static void convertRequirements(NodeType toscaElement, Component component) { + Map toscaRequirements = toscaElement.getRequirements(); + + Map> compReqs = new HashMap<>(); + if (toscaRequirements == null || toscaRequirements.isEmpty()) + return; + toscaRequirements.forEach((s, req) -> { + + if (req != null) { + List reqDataList = req.getListToscaDataDefinition(); + + if (reqDataList != null && !reqDataList.isEmpty()) { + List reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList()); + compReqs.put(s, reqList); + } + } + } + ); + component.setRequirements(compReqs); + } + + private static TopologyTemplate convertToTopologyTemplate(Component component) { + TopologyTemplate topologyTemplate; + ComponentTypeEnum componentType = component.getComponentType(); + topologyTemplate = new TopologyTemplate(); + + if (componentType == ComponentTypeEnum.RESOURCE) { + Resource resource = (Resource) component; + topologyTemplate.setResourceType(resource.getResourceType()); + topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID()); + topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion()); + topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum()); + convertTopologyTemplateInterfaces(resource, topologyTemplate); + } + if (componentType == ComponentTypeEnum.SERVICE) { + convertServiceSpecificEntities((Service) component, topologyTemplate); + } + convertCommonToscaData(component, topologyTemplate); + convertArtifacts(component, topologyTemplate); + + convertAdditionalInformation(component, topologyTemplate); + convertComponentInstances(component, topologyTemplate); + + convertInputs(component, topologyTemplate); + convertProperties(component, topologyTemplate); + convertCapabilities(component, topologyTemplate); + convertGroups(component, topologyTemplate); + convertPolicies(component, topologyTemplate); + convertRequirements(component, topologyTemplate); + convertRelationsToComposition(component, topologyTemplate); + + return topologyTemplate; + } + + private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) { + Map interfaces = resource.getInterfaces(); + if (interfaces != null && !interfaces.isEmpty()) { + Map copy = interfaces.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue()))); + topologyTemplate.setInterfaces(copy); + } + } + + private static void convertServiceInterfaces(Service service, TopologyTemplate topologyTemplate) { + Map interfaces = service.getInterfaces(); + if (interfaces != null && !interfaces.isEmpty()) { + Map copy = interfaces.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue()))); + topologyTemplate.setInterfaces(copy); + } + } + + private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) { + convertServiceMetaData(service, topologyTemplate); + convertServiceApiArtifacts(service, topologyTemplate); + convertServicePaths(service,topologyTemplate); + convertServiceInterfaces(service, topologyTemplate); + } + + private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) { + Map servicePaths = service.getForwardingPaths(); + if (servicePaths != null && !servicePaths.isEmpty()) { + Map copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue()))); + topologyTemplate.setForwardingPaths(copy); + } + } + + private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) { + if (service.getDistributionStatus() != null) { + topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, + service.getDistributionStatus().name()); + } + topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode()); + topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, + service.isEcompGeneratedNaming()); + topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy()); + topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext()); + topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType()); + + } + + private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) { + List componentInstancesRelations = component.getComponentInstancesRelations(); + if (componentInstancesRelations != null) { + Map compositions = topologyTemplate.getCompositions(); + if (compositions == null) { + compositions = new HashMap<>(); + } + CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + if (compositionDataDefinition == null) { + compositionDataDefinition = new CompositionDataDefinition(); + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition); + } + + Map relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null) + .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity())); + compositionDataDefinition.setRelations(relations); + } + } + + private static void convertInputs(Component component, TopologyTemplate topologyTemplate) { + List inputsList = component.getInputs(); + if (inputsList != null && !inputsList.isEmpty()) { + + Map inputsMap = inputsList.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())); + topologyTemplate.setInputs(inputsMap); + } + + } + + private static void convertInputs(TopologyTemplate topologyTemplate, Component component) { + Map inputsMap = topologyTemplate.getInputs(); + if (inputsMap != null && !inputsMap.isEmpty()) { + List inputsList = inputsMap.values() + .stream() + .map(InputDefinition::new) + .collect(Collectors.toList()); + component.setInputs(inputsList); + } + } + + private static void convertProperties(Component component, TopologyTemplate topologyTemplate) { + List propertiesList = component.getProperties(); + if (propertiesList != null && !propertiesList.isEmpty()) { + Map propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i)).collect(Collectors.toMap(i -> i.getName(), i -> i)); + topologyTemplate.setProperties(propertiesMap); + } + + } + + private static void convertProperties(TopologyTemplate topologyTemplate, Component component) { + Map proeprtiesMap = topologyTemplate.getProperties(); + if (proeprtiesMap != null && !proeprtiesMap.isEmpty()) { + Map copy = proeprtiesMap.entrySet().stream() + .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition + (entry.getValue()))); + component.setProperties(new ArrayList<>(copy.values())); + } + } + + private static void convertDataTypes(TopologyTemplate topologyTemplate, Component component) { + Map dataTypeDataMap = topologyTemplate.getDataTypes(); + if (MapUtils.isNotEmpty(dataTypeDataMap)) { + List dataTypeMap = dataTypeDataMap.values().stream().map(e -> { + DataTypeDefinition dataType = new DataTypeDefinition(e); + + if(CollectionUtils.isNotEmpty(e.getPropertiesData())) { + log.debug("#convertDataTypes - propertiesData is not null. {}", + ReflectionToStringBuilder.toString(e.getPropertiesData())); + dataType.setProperties(e.getPropertiesData().stream() + .map(PropertyDefinition::new).collect(Collectors.toList())); + } else { + log.debug("#convertDataTypes - propertiesData is null. ignore."); + } + return dataType; + }).collect(Collectors.toList()); + component.setDataTypes(dataTypeMap); + } + } + + + private static void convertCommonToscaData(Component component, ToscaElement toscaElement) { + toscaElement.setUUID(component.getUUID()); + toscaElement.setUniqueId(component.getUniqueId()); + toscaElement.setSystemName(component.getSystemName()); + toscaElement.setLifecycleState(component.getLifecycleState()); + toscaElement.setComponentType(component.getComponentType()); + toscaElement.setNormalizedName(component.getNormalizedName()); + toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName()); + toscaElement.setCategories(component.getCategories()); + toscaElement.setCreatorUserId(component.getCreatorUserId()); + toscaElement.setCreationDate(component.getCreationDate()); + toscaElement.setCreatorFullName(component.getCreatorFullName()); + toscaElement.setHighestVersion(component.isHighestVersion()); + toscaElement.setLastUpdateDate(component.getLastUpdateDate()); + toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName()); + toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId()); + toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType()); + toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion()); + + //Archive + toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived()); + toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime()); + toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived()); + + toscaElement.setLifecycleState(component.getLifecycleState()); + toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion()); + if (component.getComponentType() == ComponentTypeEnum.RESOURCE) { + toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract()); + toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName()); + toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName()); + toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease()); + // field isn't mandatory , but shouldn't be null(should be an empty string instead) + if (((Resource) component).getResourceVendorModelNumber() != null){ + toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber()); + } else { + toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ""); + } + } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) { + // field isn't mandatory , but shouldn't be null(should be an empty string instead) + if (((Service) component).getServiceType() != null){ + toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType()); + } else { + toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ""); + } + if (((Service) component).getServiceRole() != null){ + toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole()); + } else { + toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ""); + } + } + toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel()); + toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted()); + toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon()); + toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription()); + toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags()); + toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID()); + toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId()); + } + + + + + private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) { + + List componentInstances = new ArrayList<>(); + ComponentInstance currComponentInstance; + Map nodeFilterComponents = topologyTemplate.getNodeFilterComponents(); + + for (Map.Entry entry : topologyTemplate.getComponentInstances().entrySet()) { + String key = entry.getKey(); + currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key)); + if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) { + List groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList()); + currComponentInstance.setGroupInstances(groupInstances); + } + if(nodeFilterComponents != null && nodeFilterComponents.containsKey(key)){ + currComponentInstance.setNodeFilter(nodeFilterComponents.get(key)); + } + if(topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key) && topologyTemplate.getInstProperties().get(key) != null ){ + List instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList()); + currComponentInstance.setProperties(instanceProps); + } + if(topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key) && topologyTemplate.getInstInputs().get(key) != null ){ + List instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList()); + currComponentInstance.setInputs(instanceInputs); + } + if(topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key) && topologyTemplate.getComponentInstInterfaces().get(key) != null ){ + Map interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + currComponentInstance.setInterfaces(interfacesMap); + } + componentInstances.add(currComponentInstance); + + } + component.setComponentInstances(componentInstances); + } + + private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) { + if (topologyTemplate.getInstInputs() != null) { + Map> inputs = new HashMap<>(); + for (Entry entry : topologyTemplate.getInstInputs().entrySet()) { + if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { + String key = entry.getKey(); + List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList()); + inputs.put(key, componentInstanceAttributes); + } + } + component.setComponentInstancesInputs(inputs); + } + } + + private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) { + if (topologyTemplate.getInstProperties() != null) { + Map> properties = new HashMap<>(); + for (Entry entry : topologyTemplate.getInstProperties().entrySet()) { + if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { + String key = entry.getKey(); + List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue()))) + .collect(Collectors.toList()); + properties.put(key, componentInstanceAttributes); + } + } + component.setComponentInstancesProperties(properties); + } + } + + private static void setComponentInstancesInterfacesToComponent(TopologyTemplate topologyTemplate, Component component) { + if (topologyTemplate.getInstInterfaces() != null) { + Map> interfaces = new HashMap<>(); + for (Entry entry : topologyTemplate.getInstInterfaces().entrySet()) { + if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { + String key = entry.getKey(); + List componentInstanceInterfaces = entry.getValue() + .getMapToscaDataDefinition().entrySet().stream().map(e -> new + ComponentInstanceInterface(e.getKey(), e.getValue())) + .collect(Collectors.toList()); + interfaces.put(key, componentInstanceInterfaces); + } + } + component.setComponentInstancesInterfaces(interfaces); + } + else if (topologyTemplate.getComponentInstInterfaces() != null) { + Map> interfaces = new HashMap<>(); + for (Entry entry : topologyTemplate.getComponentInstInterfaces().entrySet()) { + if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { + String key = entry.getKey(); + List componentInstanceInterfaces = entry.getValue() + .getMapToscaDataDefinition().entrySet().stream().map(e -> new + ComponentInstanceInterface(e.getKey(), e.getValue())) + .collect(Collectors.toList()); + interfaces.put(key, componentInstanceInterfaces); + } + } + component.setComponentInstancesInterfaces(interfaces); + } + + } + + private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) { + if (topologyTemplate.getInstAttributes() != null) { + Map> attributes = new HashMap<>(); + for (Map.Entry entry : topologyTemplate.getInstAttributes().entrySet()) { + if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { + String key = entry.getKey(); + List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue()))) + .collect(Collectors.toList()); + attributes.put(key, componentInstanceAttributes); + } + } + component.setComponentInstancesAttributes(attributes); + } + } + + private static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) { + + if (topologyTemplate.getCalculatedRequirements() != null) { + // Requirements of component organized by capability + Map> instancesRequirements = new HashMap<>(); + + Map instancesMap = new HashMap<>(); + for (ComponentInstance currInstance : component.getComponentInstances()) { + instancesMap.put(currInstance.getUniqueId(), currInstance); + } + for (Map.Entry entry : topologyTemplate.getCalculatedRequirements().entrySet()) { + + String instanceId = entry.getKey(); + // Requirements of instance organized by capability + Map capsMapList = entry.getValue().getMapToscaDataDefinition(); + + if(capsMapList != null) { + for (Entry entryTypeList : capsMapList.entrySet()) { + String capabilityType = entryTypeList.getKey(); + List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList()); + if (instancesRequirements.containsKey(capabilityType)) { + instancesRequirements.get(capabilityType).addAll(caps); + } else { + instancesRequirements.put(capabilityType, caps); + } + if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) { + instancesMap.get(instanceId).setRequirements(new HashMap<>()); + } + instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps)); + } + } + } + component.setRequirements(instancesRequirements); + } + } + + private static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) { + Map calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties(); + + if (topologyTemplate.getCalculatedCapabilities() != null) { + // capabilities of component organized by type + Map> instancesCapabilities = new HashMap<>(); + + Map instancesMap = new HashMap<>(); + for (ComponentInstance currInstance : component.getComponentInstances()) { + instancesMap.put(currInstance.getUniqueId(), currInstance); + } + for (Map.Entry entry : topologyTemplate.getCalculatedCapabilities().entrySet()) { + + String instanceId = entry.getKey(); + // capabilities of instance organized by type + Map capsMapList = entry.getValue().getMapToscaDataDefinition(); + + if(capsMapList != null) { + for (Entry entryTypeList : capsMapList.entrySet()) { + String capabilityType = entryTypeList.getKey(); + List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList()); + if (instancesCapabilities.containsKey(capabilityType)) { + instancesCapabilities.get(capabilityType).addAll(caps); + } else { + instancesCapabilities.put(capabilityType, caps); + } + ComponentInstance instance = instancesMap.get(instanceId); + if (instance == null) { + log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME)); + } else { + if (MapUtils.isEmpty(instance.getCapabilities())) { + instance.setCapabilities(new HashMap<>()); + } + instance.getCapabilities().put(capabilityType, new ArrayList<>(caps)); + } + } + } + } + component.setCapabilities(instancesCapabilities); + } + } + + private static void setCapabilitiesToComponent(TopologyTemplate topologyTemplate, Component component) { + Map capabilities = topologyTemplate.getCapabilities(); + Map capabilitiesProperties = topologyTemplate.getCapabilitiesProperties(); + Map> allCapabilities = new HashMap<>(); + + if(MapUtils.isNotEmpty(capabilities)) { + allCapabilities.putAll(groupCapabilityByType(capabilities)); + } + + if(MapUtils.isNotEmpty(capabilitiesProperties)) { + capabilitiesProperties.forEach((s, capProp)-> { + String[] result = s.split(CAP_PROP_DELIM); + if (capProp != null) { + Map capMap = capProp.getMapToscaDataDefinition(); + + if (MapUtils.isNotEmpty(capMap)) { + List capPropsList = capMap.values().stream() + .map(ComponentInstanceProperty::new).collect(Collectors.toList()); + + List cap = allCapabilities.get(result[0]); + if (cap !=null) { + Optional op = cap.stream().filter(c -> c.getName() + .equals(result[1])).findFirst(); + op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList)); + } + } + } + } + ); + } + Map> componentCapabilities = component.getCapabilities(); + if(MapUtils.isNotEmpty(componentCapabilities)) { + mergeCapabilityMap(allCapabilities, componentCapabilities); + } + component.setCapabilities(allCapabilities); + } + + private static void mergeCapabilityMap(Map> map1, + Map> map2) { + map1.forEach((key1, val1) -> map2.forEach((key2, val2) -> { + if(key1.equals(key2)) { + val2.addAll(val1); + } + })); + map1.putAll(map2); + } + + private static Map> groupCapabilityByType(Map capabilities) { + Map> groupedCapabilities = new HashMap<>(); + + Set typesSet = new HashSet<>(); + List allCapabilityDefinitions = new ArrayList<>(); + for (Entry capabilitiesEntry : capabilities.entrySet()) { + typesSet.addAll( capabilitiesEntry.getValue().getListToscaDataDefinition() + .stream().map(CapabilityDataDefinition::getType).collect(Collectors.toSet())); + + allCapabilityDefinitions.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition() + .stream().map(CapabilityDefinition::new).collect(Collectors.toList())); + } + + for(String capType : typesSet) { + groupedCapabilities.put(capType, allCapabilityDefinitions.stream() + .filter(capabilityDefinition -> capabilityDefinition.getType() + .equals(capType)).collect(Collectors.toList())); + } + return groupedCapabilities; + } + + private static void setRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) { + Map requirements = topologyTemplate.getRequirements(); + Map> componentRequirements = component.getRequirements(); + if(MapUtils.isNotEmpty(requirements)) { + if(componentRequirements == null) { + componentRequirements = new HashMap<>(); + } + componentRequirements.putAll(groupRequirementByType(requirements)); + component.setRequirements(componentRequirements); + } + } + + private static Map> groupRequirementByType(Map requirements) { + Map> groupedRequirement = new HashMap<>(); + + Set typesSet = new HashSet<>(); + List allRequirements = new ArrayList<>(); + for (Entry requirementsEntry : requirements.entrySet()) { + typesSet.addAll( requirementsEntry.getValue().getListToscaDataDefinition() + .stream().map(RequirementDataDefinition::getCapability).collect(Collectors.toSet())); + + allRequirements.addAll(requirementsEntry.getValue().getListToscaDataDefinition() + .stream().map(RequirementDefinition::new).collect(Collectors.toList())); + } + + for(String capType : typesSet) { + groupedRequirement.put(capType, allRequirements.stream().filter(requirementDefinition -> + requirementDefinition.getCapability().equals(capType)).collect(Collectors.toList())); + } + return groupedRequirement; + + } + + + private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) { + + Map calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties(); + + if (capabilitiesAndGroupsExist(topologyTemplate, component)) { + Map groupsMap = component.getGroups().stream().collect(Collectors.toMap(GroupDefinition::getUniqueId,Function.identity())); + + for (Map.Entry entry : topologyTemplate.getCalculatedCapabilities().entrySet()) { + findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry); + } + } + } + + private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) { + return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups()); + } + + private static void findSetCapabilitiesToComponentAndGroup(Map calculatedCapProperties, Component component, Map groupsMap, Map.Entry entry) { + + String uniqueId = entry.getKey(); + if(groupsMap.containsKey(uniqueId)){ + setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId)); + } else { + log.warn("The group with uniqueId {} was not found", uniqueId); + } + } + + private static void setCapabilitiesToComponentAndGroup(Map calculatedCapProperties, Component component, Map.Entry entry, GroupDefinition group) { + + for (Entry entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) { + String capabilityType = entryTypeList.getKey(); + List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList()); + if (component.getCapabilities().containsKey(capabilityType)) { + component.getCapabilities().get(capabilityType).addAll(caps); + } else { + component.getCapabilities().put(capabilityType, caps); + } + group.getCapabilities().put(capabilityType, Lists.newArrayList(caps)); + } + } + + private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId, Map calculatedCapProperties) { + CapabilityDefinition capability = new CapabilityDefinition(cap); + if (calculatedCapProperties != null) { + MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId); + if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) { + Map toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition(); + toscaCapPropMap.forEach(( keyPath, capProp)-> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp)); + } + } + return capability; + } + + private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path, MapPropertiesDataDefinition capProp) { + // format key of capability properties : + // VF instance in service : instanceId#ownerId#type#capName + // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId + // Group in service : groupName#ownerId#type#capName + // Group in VF : groupName#type#capName -> groupName=ownerId + String[] result = path.split(CAP_PROP_DELIM); + if (result.length < 4) { + log.debug("wrong key format for capabilty, key {}", capProp); + return; + } + if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) { + capability.setProperties(capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList())); + } + } + + private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp, String[] result) { + return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result); + } + + private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) { + int primaryKeyIndex = 0; + int ownerIndex = 1; + int typeIndex = result.length - 2; + int nameIndex = result.length - 1; + return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && primaryPathKey.equals(result[primaryKeyIndex]); + } + + private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { + + Map componentInstances = new HashMap<>(); + ComponentInstanceDataDefinition convertedInstance; + if (component.getComponentInstances() != null) { + for (ComponentInstance instance : component.getComponentInstances()) { + convertedInstance = new ComponentInstanceDataDefinition(instance); + if (instance.getGroupInstances() != null) { + MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition(); + + groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new).collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity()))); + if (topologyTemplate.getInstGroups() == null) { + topologyTemplate.setInstGroups(new HashMap<>()); + } + topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap); + } + componentInstances.put(instance.getUniqueId(), convertedInstance); + } + } + topologyTemplate.setComponentInstances(componentInstances); + + } + + private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { + + if (component.getComponentInstancesInputs() != null) { + topologyTemplate.setInstInputs(new HashMap<>()); + MapPropertiesDataDefinition inputsMap; + for (Entry> entry : component.getComponentInstancesInputs().entrySet()) { + inputsMap = new MapPropertiesDataDefinition(); + + inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); + + topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap); + } + } + } + + private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { + + if (component.getComponentInstancesProperties() != null) { + topologyTemplate.setInstProperties(new HashMap<>()); + MapPropertiesDataDefinition propertiesMap; + for (Entry> entry : component.getComponentInstancesProperties().entrySet()) { + propertiesMap = new MapPropertiesDataDefinition(); + + propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); + + topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap); + } + } + } + + private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { + + List componentInstances = component.getComponentInstances(); + if (componentInstances != null) { + topologyTemplate.setInstanceArtifacts(new HashMap<>()); + topologyTemplate.setInstDeploymentArtifacts(new HashMap<>()); + + for (ComponentInstance ci : componentInstances) { + Map artifacts = ci.getArtifacts(); + if (artifacts != null) { + Map mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact); + topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact); + } + + Map deplArtifacts = ci.getDeploymentArtifacts(); + if (deplArtifacts != null) { + Map mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); + MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact); + topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact); + } + } + } + } + + private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { + + if (component.getComponentInstancesAttributes() != null) { + topologyTemplate.setInstAttributes(new HashMap<>()); + MapPropertiesDataDefinition attributesMap; + for (Entry> entry : component.getComponentInstancesAttributes().entrySet()) { + attributesMap = new MapPropertiesDataDefinition(); + + attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); + + topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap); + } + } + } + + public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) { + ComponentMetadataData metadata = null; + switch (vertex.getType()) { + case SERVICE: + metadata = new ServiceMetadataData(vertex.getMetadataJson()); + break; + case RESOURCE: + metadata = new ResourceMetadataData(vertex.getMetadataJson()); + break; + case PRODUCT: + metadata = new ProductMetadataData(vertex.getMetadataJson()); + break; + default: + break; + } + if (metadata != null) { + metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId()); + metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE)); + metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID)); + metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)); + } + return metadata; + } + + public static List convertToGroupDefinitions(Map groups) { + + List groupDefinitions = null; + if (MapUtils.isNotEmpty(groups)) { + groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList()); + } + return groupDefinitions; + } + + public static Map extractCapabilityProperteisFromInstances(List instances, boolean fromCsar) { + return instances + .stream() + .collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId, + ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar))); + } + + public static Map extractCapabilityPropertiesFromGroups(List groups, boolean fromCsar) { + if(CollectionUtils.isNotEmpty(groups)) + return groups + .stream() + .collect(Collectors.toMap(GroupDefinition::getUniqueId, + g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar))); + return Maps.newHashMap(); + } + + public static Map extractCapabilitiesFromGroups(final List groupDefinitions) { + Map calculatedCapabilities = Maps.newHashMap(); + for(GroupDefinition groupDefinition :groupDefinitions){ + calculatedCapabilities.put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition))); + } + return calculatedCapabilities; + } + + public static Map buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) { + return groupDefinition.getCapabilities().entrySet() + .stream() + .collect(Collectors.toMap(Map.Entry::getKey, e-> new ListCapabilityDataDefinition(e.getValue() + .stream() + .map(CapabilityDataDefinition::new) + .collect(Collectors.toList())))); + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeType.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeType.java deleted file mode 100644 index 4babd5d4a8..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeType.java +++ /dev/null @@ -1,71 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.openecomp.sdc.be.datatypes.elements.*; - -import java.util.List; -import java.util.Map; - -public class NodeType extends ToscaElement{ - - public NodeType() { - super(ToscaElementTypeEnum.NODE_TYPE); - } - - private List derivedFrom; - private List derivedList; - private Map attributes; - private Map interfaceArtifacts; - - public List getDerivedList() { - return derivedList; - } - - public void setDerivedList(List derivedList) { - this.derivedList = derivedList; - } - - public List getDerivedFrom() { - return derivedFrom; - } - - public void setDerivedFrom(List derivedFrom) { - this.derivedFrom = derivedFrom; - } - - public Map getAttributes() { - return attributes; - } - - public void setAttributes(Map attributes) { - this.attributes = attributes; - } - - public Map getInterfaceArtifacts() { - return interfaceArtifacts; - } - - public void setInterfaceArtifacts(Map interfaceArtifacts) { - this.interfaceArtifacts = interfaceArtifacts; - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplate.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplate.java deleted file mode 100644 index 8c0253a148..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplate.java +++ /dev/null @@ -1,311 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.apache.commons.collections.MapUtils; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.DataTypeDefinition; -import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; - -import java.util.HashMap; -import java.util.Map; - -public class TopologyTemplate extends ToscaElement{ - - public TopologyTemplate() { - super(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE); - } - private Map inputs; - private Map instInputs; - private Map heatParameters; - private Map instAttributes; - private Map instProperties; - private Map groups; - private Map policies; - private Map instGroups; - private Map serviceApiArtifacts; - private Map forwardingPaths; - private Map compositions; - private Map calculatedCapabilities; - private Map calculatedRequirements; - private Map fullfilledCapabilities; - private Map fullfilledRequirements; - private Map calculatedCapabilitiesProperties; - private Map instDeploymentArtifacts; - private Map instanceArtifacts; - private Map interfaces; - private Map instInterfaces; - private Map componentInstInterfaces; - private Map dataTypes; - - private Map nodeFilterComponents; - //Component Instances External References (instanceId -> ExternalRefsMap) - //----------------------------------------------------------------------- - private Map mapComponentInstancesExternalRefs; - - public Map getMapComponentInstancesExternalRefs() { - return this.mapComponentInstancesExternalRefs; - } - - public void setComponentInstancesExternalRefs(Map mapComponentInstancesExternalRefs) { - this.mapComponentInstancesExternalRefs = mapComponentInstancesExternalRefs; - } - //----------------------------------------------------------------------- - - public Map getInterfaces() { - return interfaces; - } - - public void setInterfaces(Map interfaces) { - this.interfaces = interfaces; - } - - public Map getInstInterfaces() { - return instInterfaces; - } - - public void setInstInterfaces( - Map instInterfaces) { - this.instInterfaces = instInterfaces; - } - - public void addInstInterface(String compId, MapInterfaceInstanceDataDefinition - mapInterfaceInstanceDataDefinition) { - if(MapUtils.isEmpty(this.instInterfaces)) { - this.instInterfaces = new HashMap<>(); - } - - this.instInterfaces.put(compId, mapInterfaceInstanceDataDefinition); - } - - public Map getComponentInstInterfaces() { - return componentInstInterfaces; - } - - public void setComponentInstInterfaces( - Map componentInstInterfaces) { - this.componentInstInterfaces = componentInstInterfaces; - } - - public void addComponentInstanceInterfaceMap(String componentInstanceId, MapInterfaceDataDefinition - mapInterfaceDataDefinition) { - if(MapUtils.isEmpty(this.componentInstInterfaces)) { - this.componentInstInterfaces = new HashMap<>(); - } - - this.componentInstInterfaces.put(componentInstanceId, mapInterfaceDataDefinition); - } - - - public Map getInputs() { - return inputs; - } - public void setInputs(Map inputs) { - this.inputs = inputs; - } - public Map getInstInputs() { - return instInputs; - } - public void setInstInputs(Map instInputs) { - this.instInputs = instInputs; - } - public Map getHeatParameters() { - return heatParameters; - } - public void setHeatParameters(Map heatParameters) { - this.heatParameters = heatParameters; - } - public Map getInstAttributes() { - return instAttributes; - } - public void setInstAttributes(Map instAttributes) { - this.instAttributes = instAttributes; - } - public Map getInstProperties() { - return instProperties; - } - public void setInstProperties(Map instProperties) { - this.instProperties = instProperties; - } - public Map getGroups() { - return groups; - } - public void setGroups(Map groups) { - this.groups = groups; - } - public Map getPolicies() { - return policies; - } - public void setPolicies(Map policies) { - this.policies = policies; - } - public Map getInstGroups() { - return instGroups; - } - public void setInstGroups(Map instGroups) { - this.instGroups = instGroups; - } - public Map getServiceApiArtifacts() { - return serviceApiArtifacts; - } - public void setServiceApiArtifacts(Map serviceApiArtifacts) { - this.serviceApiArtifacts = serviceApiArtifacts; - } - public Map getCompositions() { - return compositions; - } - public void setCompositions(Map compositions) { - this.compositions = compositions; - } - public Map getCalculatedCapabilities() { - return calculatedCapabilities; - } - public void setCalculatedCapabilities(Map calculatedCapabilities) { - this.calculatedCapabilities = calculatedCapabilities; - } - public Map getCalculatedRequirements() { - return calculatedRequirements; - } - public void setCalculatedRequirements(Map calculatedRequirements) { - this.calculatedRequirements = calculatedRequirements; - } - public Map getFullfilledCapabilities() { - return fullfilledCapabilities; - } - public void setFullfilledCapabilities(Map fullfilledCapabilities) { - this.fullfilledCapabilities = fullfilledCapabilities; - } - public Map getFullfilledRequirements() { - return fullfilledRequirements; - } - public void setFullfilledRequirements(Map fullfilledRequirements) { - this.fullfilledRequirements = fullfilledRequirements; - } - - public Map getInstDeploymentArtifacts() { - return instDeploymentArtifacts; - } - public void setInstDeploymentArtifacts(Map instDeploymentArtifacts) { - this.instDeploymentArtifacts = instDeploymentArtifacts; - } - - public Map getCalculatedCapabilitiesProperties() { - return calculatedCapabilitiesProperties; - } - public void setCalculatedCapabilitiesProperties(Map calculatedCapabilitiesProperties) { - this.calculatedCapabilitiesProperties = calculatedCapabilitiesProperties; - } - - public Map getInstanceArtifacts() { - return instanceArtifacts; - } - public void setInstanceArtifacts(Map instanceArtifacts) { - this.instanceArtifacts = instanceArtifacts; - } - - public Map getForwardingPaths() { - return forwardingPaths; - } - - public void setForwardingPaths(Map forwardingPaths) { - this.forwardingPaths = forwardingPaths; - } - - public Map getNodeFilterComponents() { - return nodeFilterComponents; - } - - public void setNodeFilterComponents(Map nodeFilters) { - this.nodeFilterComponents = nodeFilters; - } - - /** - * Gets data types. - * @return Current data types. - */ - public Map getDataTypes() { - return dataTypes; - } - - /** - * Sets data types. - * @param dataTypes New data types. - */ - public void setDataTypes(Map dataTypes) { - this.dataTypes = dataTypes; - } - - /** - * Adds component instance to composition of topology template - * Note that component instance will be overrided in case if the topology template already contains a component instance with the same name - * @param componentInstance - */ - public void addComponentInstance(ComponentInstanceDataDefinition componentInstance){ - if(getCompositions() == null){ - compositions = new HashMap<>(); - } - if(MapUtils.isEmpty(getCompositions())){ - compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition()); - } - if(MapUtils.isEmpty(getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances())){ - getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(new HashMap<>()); - } - getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances().put(componentInstance.getUniqueId(), componentInstance); - } - /** - * Returns map of component instances from composition - * @return - */ - public Map getComponentInstances() { - Map instances = null; - if(getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){ - instances = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances(); - } - return instances; - } - - - /** - * Sets map of component instances to composition of topology template - * Note that component instances will be overrided in case if the topology template already contains a component instances - * @param instances - */ - public void setComponentInstances(Map instances) { - if(getCompositions() == null){ - compositions = new HashMap<>(); - } - if(MapUtils.isEmpty(getCompositions())){ - compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition()); - } - getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(instances); - } - public Map getRelations() { - Map relations = null; - if( getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){ - relations = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getRelations(); - } - return relations; - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElement.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElement.java deleted file mode 100644 index a18c75bca7..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElement.java +++ /dev/null @@ -1,344 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation; -import org.slf4j.MDC; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.UUID; - -public abstract class ToscaElement { - - protected Map metadata; - protected List categories; - protected Map toscaArtifacts; - private Map artifacts; - private Map deploymentArtifacts; - private Map additionalInformation; - private Map properties; - private Map capabilities; - private Map capabiltiesProperties; - private Map requirements; - - protected ToscaElementTypeEnum toscaType; - // User - private String creatorUserId; - private String creatorFullName; - private String lastUpdaterUserId; - private String lastUpdaterFullName; - - private Map allVersions; - - public ToscaElement(ToscaElementTypeEnum toscaType){ - this.toscaType = toscaType; - } - - public Map getMetadata() { - return metadata; - } - - public void setMetadata(Map metadata) { - this.metadata = metadata; - } - - public List getCategories() { - return categories; - } - - public void setCategories(List categories) { - this.categories = categories; - } - public Map getToscaArtifacts() { - return toscaArtifacts; - } - - public void setToscaArtifacts(Map toscaArtifacts) { - this.toscaArtifacts = toscaArtifacts; - } - - public ToscaElementTypeEnum getToscaType() { - return toscaType; - } - - public void setToscaType(ToscaElementTypeEnum toscaType) { - this.toscaType = toscaType; - } - public Map getArtifacts() { - return artifacts; - } - - public void setArtifacts(Map artifacts) { - this.artifacts = artifacts; - } - - public Map getDeploymentArtifacts() { - return deploymentArtifacts; - } - - public void setDeploymentArtifacts(Map deploymentArtifacts) { - this.deploymentArtifacts = deploymentArtifacts; - } - public Map getAdditionalInformation() { - return additionalInformation; - } - public void setAdditionalInformation(Map additionalInformation) { - this.additionalInformation = additionalInformation; - } - public Map getProperties() { - return properties; - } - public void setProperties(Map properties) { - this.properties = properties; - } - - public Map getAllVersions() { - return allVersions; - } - - public void setAllVersions(Map allVersions) { - this.allVersions = allVersions; - } - - public Map getCapabilities() { - return capabilities; - } - - public void setCapabilities(Map capabilities) { - this.capabilities = capabilities; - } - - public Map getRequirements() { - return requirements; - } - - public void setRequirements(Map requirements) { - this.requirements = requirements; - } - - public Map getCapabilitiesProperties() { - return capabiltiesProperties; - } - - public void setCapabilitiesProperties(Map capabiltiesProperties) { - this.capabiltiesProperties = capabiltiesProperties; - } - - // metadata properties - // ---------------------------- - public Object getMetadataValue(JsonPresentationFields name) { - return getMetadataValueOrDefault(name, null); - } - - public Object getMetadataValueOrDefault(JsonPresentationFields name, Object defaultVal) { - if (metadata != null) { - return metadata.getOrDefault(name.getPresentation(), defaultVal); - } - return null; - } - - public void setMetadataValue(JsonPresentationFields name, Object value) { - if (metadata == null) { - metadata = new HashMap<>(); - } - metadata.put(name.getPresentation(), value); - - } - // -------------------- - public String getUUID() { - return (String) getMetadataValue(JsonPresentationFields.UUID); - } - - public void setUUID(String uuid) { - setMetadataValue(JsonPresentationFields.UUID, uuid); - } - - public String getVersion() { - return (String) getMetadataValue(JsonPresentationFields.VERSION); - } - - public String getNormalizedName() { - return (String) getMetadataValue(JsonPresentationFields.NORMALIZED_NAME); - } - - public void setNormalizedName(String normaliseComponentName) { - setMetadataValue(JsonPresentationFields.NORMALIZED_NAME, normaliseComponentName); - } - - public String getName() { - return (String) getMetadataValue(JsonPresentationFields.NAME); - } - - public String getSystemName() { - return (String) getMetadataValue(JsonPresentationFields.SYSTEM_NAME); - } - public void setSystemName(String systemName) { - setMetadataValue(JsonPresentationFields.SYSTEM_NAME, systemName); - } - - public void setLifecycleState(LifecycleStateEnum state) { - if(state != null) - setMetadataValue(JsonPresentationFields.LIFECYCLE_STATE, state.name()); - } - - public LifecycleStateEnum getLifecycleState() { - return LifecycleStateEnum.findState( (String) getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); - } - - public Long getCreationDate() { - return (Long) getMetadataValue(JsonPresentationFields.CREATION_DATE); - } - - public void setCreationDate(Long currentDate) { - setMetadataValue(JsonPresentationFields.CREATION_DATE, currentDate); - } - - public void setLastUpdateDate(Long currentDate) { - setMetadataValue(JsonPresentationFields.LAST_UPDATE_DATE, currentDate); - } - public Long getLastUpdateDate() { - return (Long) getMetadataValue(JsonPresentationFields.LAST_UPDATE_DATE); - } - - public String getUniqueId() { - return (String) getMetadataValue(JsonPresentationFields.UNIQUE_ID); - } - public void setUniqueId(String uniqueId) { - setMetadataValue(JsonPresentationFields.UNIQUE_ID, uniqueId); - } - - public void setHighestVersion(Boolean isHighest) { - setMetadataValue(JsonPresentationFields.HIGHEST_VERSION, isHighest); - - } - public Boolean isHighestVersion() { - return (Boolean) getMetadataValue(JsonPresentationFields.HIGHEST_VERSION); - - } - public ResourceTypeEnum getResourceType() { - String resourceType = (String) getMetadataValue(JsonPresentationFields.RESOURCE_TYPE); - return resourceType != null ? ResourceTypeEnum.valueOf(resourceType) : null; - } - - public void setResourceType(ResourceTypeEnum resourceType) { - if(resourceType != null) - setMetadataValue(JsonPresentationFields.RESOURCE_TYPE, resourceType.name()); - } - - public ComponentTypeEnum getComponentType() { - return ComponentTypeEnum.valueOf((String) getMetadataValue(JsonPresentationFields.COMPONENT_TYPE)); - } - - public void setComponentType(ComponentTypeEnum componentType) { - if(componentType != null) - setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, componentType.name()); - } - - public String getDerivedFromGenericType(){ - return (String) getMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_TYPE); - } - - public void setDerivedFromGenericType(String derivedFromGenericType){ - setMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_TYPE, derivedFromGenericType); - } - - public String getDerivedFromGenericVersion(){ - return (String) getMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_VERSION); - } - - public void setDerivedFromGenericVersion(String derivedFromGenericVersion){ - setMetadataValue(JsonPresentationFields.DERIVED_FROM_GENERIC_VERSION, derivedFromGenericVersion); - } - - public Boolean isArchived() { return (Boolean) getMetadataValue(JsonPresentationFields.IS_ARCHIVED); } - - public void setArchived(Boolean archived) { setMetadataValue(JsonPresentationFields.IS_ARCHIVED, archived); } - - public Long getArchiveTime() { - Object archiveTime = getMetadataValue(JsonPresentationFields.ARCHIVE_TIME); - if (archiveTime instanceof Integer){ - return new Long((Integer)getMetadataValue(JsonPresentationFields.ARCHIVE_TIME)); - } - return (Long)archiveTime; - } - - public void setArchiveTime(Long archiveTime) { setMetadataValue(JsonPresentationFields.ARCHIVE_TIME, archiveTime); } - - public Boolean isVspArchived() { return (Boolean) getMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED); } - - public void setVspArchived(Boolean vspArchived) { setMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED, vspArchived); } - - public String getCreatorUserId() { - return creatorUserId; - } - - public void setCreatorUserId(String creatorUserId) { - this.creatorUserId = creatorUserId; - } - - public String getCreatorFullName() { - return creatorFullName; - } - - public void setCreatorFullName(String creatorFullName) { - this.creatorFullName = creatorFullName; - } - - public String getLastUpdaterUserId() { - return lastUpdaterUserId; - } - - public void setLastUpdaterUserId(String lastUpdaterUserId) { - this.lastUpdaterUserId = lastUpdaterUserId; - } - - public String getLastUpdaterFullName() { - return lastUpdaterFullName; - } - - public void setLastUpdaterFullName(String lastUpdaterFullName) { - this.lastUpdaterFullName = lastUpdaterFullName; - } - - public void generateUUID() { - String prevUUID = getUUID(); - String version = getVersion(); - if ((prevUUID == null && NodeTypeOperation.uuidNormativeNewVersion.matcher(version).matches()) || NodeTypeOperation.uuidNewVersion.matcher(version).matches()) { - UUID uuid = UUID.randomUUID(); - setUUID(uuid.toString()); - MDC.put("serviceInstanceID", uuid.toString()); - } - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnum.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnum.java deleted file mode 100644 index 3ee492b9bb..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnum.java +++ /dev/null @@ -1,49 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; - -public enum ToscaElementTypeEnum { - NODE_TYPE("node_type"), - TOPOLOGY_TEMPLATE("topology_template"); - - String value; - private ToscaElementTypeEnum(String value){ - this.value = value; - } - - public static VertexTypeEnum getVertexTypeByToscaType(ToscaElementTypeEnum toscaType ){ - switch ( toscaType ){ - case NODE_TYPE : - return VertexTypeEnum.NODE_TYPE; - case TOPOLOGY_TEMPLATE : - return VertexTypeEnum.TOPOLOGY_TEMPLATE; - default : - return null; - } - } - - public String getValue() { - return value; - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnum.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnum.java deleted file mode 100644 index 2a4496e793..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnum.java +++ /dev/null @@ -1,42 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.enums; - -public enum JsonConstantKeysEnum { - - COMPOSITION("composition"), - CAPABILITIES("capabilities"), - REQUIREMENTS("requirements"), - PROPERTIES("properties"), - INPUTS("inputs"), - GROUPS("groups"), - INSTANCE_PROPERIES("instanceProperties"); - - private String value; - - private JsonConstantKeysEnum(String value) { - this.value = value; - } - - public String getValue() { - return value; - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperation.java deleted file mode 100644 index f4033a2ffb..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperation.java +++ /dev/null @@ -1,284 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -import java.util.*; -import java.util.stream.Collectors; - -import static org.openecomp.sdc.be.model.jsontitan.operations.ArchiveOperation.Action.ARCHIVE; -import static org.openecomp.sdc.be.model.jsontitan.operations.ArchiveOperation.Action.RESTORE; - -/** - * Created by yavivi on 25/03/2018. - */ -@Component -public class ArchiveOperation extends BaseOperation { - - private static final Logger log = Logger.getLogger(ArchiveOperation.class.getName()); - - @Autowired - private IGraphLockOperation graphLockOperation; - - public enum Action { - ARCHIVE, RESTORE; - } - - public ArchiveOperation(TitanDao titanDao, IGraphLockOperation graphLockOperation){ - this.titanDao = titanDao; - this.graphLockOperation = graphLockOperation; - } - - public Either, ActionStatus> archiveComponent(String componentId) { - final Either vertexResult = this.titanDao.getVertexById(componentId); - if (vertexResult.isLeft()){ - return doAction(ARCHIVE, vertexResult.left().value()); - } else { - return Either.right(onError(ARCHIVE.name(), componentId, vertexResult.right().value())); - } - } - - public Either, ActionStatus> restoreComponent(String componentId) { - final Either vertexResult = this.titanDao.getVertexById(componentId); - if (vertexResult.isLeft()){ - return doAction(RESTORE, vertexResult.left().value()); - } else { - return Either.right(onError(RESTORE.name(), componentId, vertexResult.right().value())); - } - } - - public ActionStatus onVspRestored(String csarId){ - return onVspStateChanged(RESTORE, csarId); - } - - public ActionStatus onVspArchived(String csarId){ - return onVspStateChanged(ARCHIVE, csarId); - } - - private ActionStatus onVspStateChanged(Action action, String csarId) { - Map props = new HashMap<>(); - props.put(GraphPropertyEnum.CSAR_UUID, csarId); - Either, TitanOperationStatus> vfsE = titanDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props); - return vfsE.either(vList -> setVspArchived(action, vList), s -> onError("VSP_"+action.name(), csarId, s)); - } - - private ActionStatus setVspArchived(Action action, List vList) { - if (!vList.isEmpty()) { - //Find & Lock the highest version component - GraphVertex highestVersion = this.getHighestVersionFrom(vList.get(0)); - StorageOperationStatus lockStatus = this.graphLockOperation.lockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); - if (lockStatus != StorageOperationStatus.OK){ - return onError(action.name(), highestVersion.getUniqueId(), TitanOperationStatus.ALREADY_LOCKED); - } - - try { - //Set isVspArchived flag - for (GraphVertex v : vList) { - boolean val = action == ARCHIVE ? true : false; - v.setJsonMetadataField(JsonPresentationFields.IS_VSP_ARCHIVED, val); - v.addMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED, val); - titanDao.updateVertex(v); - } - return commitAndCheck("VSP_"+action.name(), vList.toString()); - } finally { - this.graphLockOperation.unlockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); - } - - } - return ActionStatus.OK; - } - - public List setArchivedOriginsFlagInComponentInstances(GraphVertex compositionService) { - List ciUidsWithArchivedOrigins = new LinkedList(); - Either, TitanOperationStatus> instanceOfVerticesE = titanDao.getChildrenVertecies(compositionService, EdgeLabelEnum.INSTANCE_OF, JsonParseFlagEnum.NoParse); - Either, TitanOperationStatus> proxyOfVerticesE = titanDao.getChildrenVertecies(compositionService, EdgeLabelEnum.PROXY_OF, JsonParseFlagEnum.NoParse); - - List all = new LinkedList<>(); - if (instanceOfVerticesE.isLeft()){ - all.addAll(instanceOfVerticesE.left().value()); - } - if (proxyOfVerticesE.isLeft()){ - all.addAll(proxyOfVerticesE.left().value()); - } - - List archivedOrigins = all.stream().filter(v -> Boolean.TRUE.equals(v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED))).collect(Collectors.toList()); - List archivedOriginsUids = archivedOrigins.stream().map(GraphVertex::getUniqueId).collect(Collectors.toList()); - - Map compositionsJson = (Map) compositionService.getJson(); - - if (compositionsJson != null) { - CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - if (composition != null) { - - //Get all component instances from composition - Map componentInstances = composition.getComponentInstances(); - - //Extract component instances uids that has archived origins - ciUidsWithArchivedOrigins = componentInstances. - values(). - stream(). - //filter CIs whose origins are marked as archived (componentUid is in archivedOriginsUids) the second condition handles the PROXY_OF case) - filter(ci -> archivedOriginsUids.contains(ci.getComponentUid()) || archivedOriginsUids.contains(ci.getToscaPresentationValue(JsonPresentationFields.CI_SOURCE_MODEL_UID))). - map(ComponentInstanceDataDefinition::getUniqueId).collect(Collectors.toList()); - - //set archived origins flag - componentInstances. - values(). - stream(). - filter(ci -> archivedOriginsUids.contains(ci.getComponentUid()) || archivedOriginsUids.contains(ci.getToscaPresentationValue(JsonPresentationFields.CI_SOURCE_MODEL_UID))). - forEach( ci -> ci.setOriginArchived(true)); - - } - } - - return ciUidsWithArchivedOrigins; - } - - private Either, ActionStatus> doAction(Action action, GraphVertex componentVertex){ - - GraphVertex highestVersion = this.getHighestVersionFrom(componentVertex); - - if (action.equals(ARCHIVE) && isInCheckoutState(highestVersion)) { - return Either.right(ActionStatus.INVALID_SERVICE_STATE); - } - - //Lock the Highest Version - StorageOperationStatus lockStatus = this.graphLockOperation.lockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); - if (lockStatus != StorageOperationStatus.OK){ - return Either.right(onError(action.name(), componentVertex.getUniqueId(), TitanOperationStatus.ALREADY_LOCKED)); - } - - //Refetch latest version with full parsing - highestVersion = this.titanDao.getVertexById(highestVersion.getUniqueId(), JsonParseFlagEnum.ParseAll).left().value(); - - try { - //Get Catalog and Archive Roots - GraphVertex catalogRoot = titanDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT).left().value(); - GraphVertex archiveRoot = titanDao.getVertexByLabel(VertexTypeEnum.ARCHIVE_ROOT).left().value(); - - if (action == ARCHIVE) { - archiveEdges(catalogRoot, archiveRoot, highestVersion); - } else if (action == RESTORE) { - restoreEdges(catalogRoot, archiveRoot, highestVersion); - } - setPropertiesByAction(highestVersion, action); - titanDao.updateVertex(highestVersion); - - List affectedComponentIds = handleParents(highestVersion, catalogRoot, archiveRoot, action); - ActionStatus sc = commitAndCheck(action.name(), highestVersion.getUniqueId()); - return sc == ActionStatus.OK ? Either.left(affectedComponentIds) : Either.right(sc); - } finally { - this.graphLockOperation.unlockComponent(highestVersion.getUniqueId(), highestVersion.getType().getNodeType()); - } - } - - private ActionStatus commitAndCheck(String action, String componentId) { - TitanOperationStatus status = titanDao.commit(); - if (!status.equals(TitanOperationStatus.OK)){ - return onError(action, componentId, status); - } - return ActionStatus.OK; - } - - private boolean isInCheckoutState(GraphVertex v) { - if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name().equals(v.getMetadataProperty(GraphPropertyEnum.STATE))){ - return true; - } - return false; - } - - /** - * Walks on children until highest version is reached - * @param v - * @return - */ - private GraphVertex getHighestVersionFrom(GraphVertex v) { - Either childVertexE = titanDao.getChildVertex(v, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - GraphVertex highestVersionVertex = v; - - while (childVertexE.isLeft()) { - highestVersionVertex = childVertexE.left().value(); - childVertexE = titanDao.getChildVertex(highestVersionVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - } - return highestVersionVertex; - } - - private boolean isHighestVersion(GraphVertex v){ - Boolean highest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - return highest != null && highest; - } - - private List handleParents(GraphVertex v, GraphVertex catalogRoot, GraphVertex archiveRoot, Action action) { - Either parentVertexE = titanDao.getParentVertex(v, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); - List affectedCompIds = new ArrayList(); - affectedCompIds.add(v.getUniqueId()); - - while (parentVertexE.isLeft()){ - GraphVertex cv = parentVertexE.left().value(); - affectedCompIds.add(cv.getUniqueId()); - boolean isHighestVersion = isHighestVersion(cv); - if (isHighestVersion){ - if (action == ARCHIVE) { - archiveEdges(catalogRoot, archiveRoot, cv); - } else { - restoreEdges(catalogRoot, archiveRoot, cv); - } - } - setPropertiesByAction(cv, action); - titanDao.updateVertex(cv); - parentVertexE = titanDao.getParentVertex(cv, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); - } - return affectedCompIds; - } - - private void archiveEdges(GraphVertex catalogRoot, GraphVertex archiveRoot, GraphVertex v) { - titanDao.deleteAllEdges(catalogRoot, v, EdgeLabelEnum.CATALOG_ELEMENT); - titanDao.createEdge(archiveRoot, v, EdgeLabelEnum.ARCHIVE_ELEMENT, null); - setPropertiesByAction(v, ARCHIVE); - } - - private void restoreEdges(GraphVertex catalogRoot, GraphVertex archiveRoot, GraphVertex v) { - titanDao.deleteAllEdges(archiveRoot, v, EdgeLabelEnum.ARCHIVE_ELEMENT); - titanDao.createEdge(catalogRoot, v, EdgeLabelEnum.CATALOG_ELEMENT, null); - setPropertiesByAction(v, RESTORE); - } - - private void setPropertiesByAction(GraphVertex v, Action action) { - long now = System.currentTimeMillis(); - - boolean isArchived = action == ARCHIVE ? true : false; - v.addMetadataProperty(GraphPropertyEnum.IS_ARCHIVED, isArchived); - v.addMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME, now); - v.setJsonMetadataField(JsonPresentationFields.IS_ARCHIVED, isArchived); - v.setJsonMetadataField(JsonPresentationFields.ARCHIVE_TIME, now); - } - - private ActionStatus onError(String action, String componentId, TitanOperationStatus s) { - ActionStatus ret = ActionStatus.GENERAL_ERROR; - if (s == TitanOperationStatus.NOT_FOUND){ - ret = ActionStatus.RESOURCE_NOT_FOUND; - } else if (s == TitanOperationStatus.ALREADY_LOCKED) { - ret = ActionStatus.COMPONENT_IN_USE; - } - String retCodeVal = ret.name(); - log.error("error occurred when trying to {} {}. Return code is: {}", action, componentId, retCodeVal); - return ret; - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.java deleted file mode 100644 index 3eb6a5211c..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperations.java +++ /dev/null @@ -1,758 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang3.tuple.ImmutableTriple; -import org.apache.commons.lang3.tuple.Triple; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.openecomp.sdc.be.config.BeEcompErrorManager; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.HeatParameterDefinition; -import org.openecomp.sdc.be.model.InterfaceDefinition; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; -import org.openecomp.sdc.common.api.ArtifactTypeEnum; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.slf4j.MDC; - -import java.util.*; -import java.util.Map.Entry; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("artifacts-operations") - -public class ArtifactsOperations extends BaseOperation { - private static final String FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR = "failed to fetch {} for tosca element with id {}, error {}"; - private static final Logger log = Logger.getLogger(ArtifactsOperations.class.getName()); - - public Either addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, String instanceId) { - - String artifactId = artifactInfo.getUniqueId(); - if (artifactId == null && artifactInfo.getEsId() != null) { - artifactId = artifactInfo.getEsId(); - } - Either status = updateArtifactOnGraph(parentId, artifactInfo, type, artifactId, instanceId, false, false); - if (status.isRight()) { - - log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), parentId, status.right().value()); - BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value())); - return Either.right(status.right().value()); - } else { - - ArtifactDataDefinition artifactData = status.left().value(); - - ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData); - log.debug("The returned ArtifactDefintion is {}", artifactDefResult); - return Either.left(artifactDefResult); - } - - } - - public Either updateArtifactOnResource(ArtifactDefinition artifactInfo, String id, String artifactId, NodeTypeEnum type, String instanceId) { - - Either status = updateArtifactOnGraph(id, artifactInfo, type, artifactId, instanceId, true, false); - if (status.isRight()) { - - log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), id, status.right().value()); - BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value())); - return Either.right(status.right().value()); - } else { - - ArtifactDataDefinition artifactData = status.left().value(); - - ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData); - log.debug("The returned ArtifactDefintion is {}", artifactDefResult); - return Either.left(artifactDefResult); - } - } - - public Either isCloneNeeded(String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum type) { - ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType(); - - Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type); - EdgeLabelEnum edgeLabelEnum = triple.getLeft(); - return super.isCloneNeeded(parentId, edgeLabelEnum); - } - - public Either getArtifactById(String parentId, String id) { - return getArtifactById(parentId, id, null, null); - } - - public Either getArtifactById(String parentId, String id, ComponentTypeEnum componentType, String containerId) { - Either result = null; - ArtifactDataDefinition foundArtifact = null; - if (componentType != null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) { - foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - if (foundArtifact == null) { - foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INSTANCE_ARTIFACTS); - } - } - if (foundArtifact == null) { - foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); - } - if (foundArtifact == null) { - foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.TOSCA_ARTIFACTS); - } - - if (foundArtifact == null) { - foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.ARTIFACTS); - } - - if (foundArtifact == null) { - foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.SERVICE_API_ARTIFACTS); - } - if (foundArtifact == null) { - foundArtifact = findInterfaceArtifact(parentId, id); - - } - - if (foundArtifact == null) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - return result; - } - - ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(null, foundArtifact); - return Either.left(artifactDefResult); - - } - private ArtifactDataDefinition findInterfaceArtifact(String parentId, String id) { - Either, TitanOperationStatus> dataFromGraph = getDataFromGraph(parentId, EdgeLabelEnum.INTERFACE); - if (dataFromGraph.isRight()){ - log.debug("failed to fetch interfaces {} for tosca element with id {}, error {}", id, parentId ,dataFromGraph.right().value()); - return null; - } - - Map interfaceDefinitionMap = dataFromGraph.left().value(); - if(interfaceDefinitionMap == null) { - return null; - } - Collection interfaces = interfaceDefinitionMap.values(); - if (interfaces == null){ - return null; - } - for (InterfaceDataDefinition interfaceDataDefinition : interfaces){ - Map operationsMap = interfaceDataDefinition.getOperations(); - if (operationsMap == null) { - return null; - } - ArtifactDataDefinition implementationArtifact = getArtifactDataDefinition(id, operationsMap); - if (implementationArtifact != null) - return implementationArtifact; - } - return null; - } - - private ArtifactDataDefinition getArtifactDataDefinition(String id, - Map operationsMap) { - for(OperationDataDefinition operationDataDefinition : operationsMap.values()){ - ArtifactDataDefinition implementationArtifact = operationDataDefinition.getImplementation(); - if(implementationArtifact != null){ - String uniqueId = implementationArtifact.getUniqueId(); - if (id.equals(uniqueId)) { - return implementationArtifact; - } - } - } - return null; - } - - - public Either removeArifactFromResource(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { - Either status = removeArtifactOnGraph(id, artifactId, type, deleteMandatoryArtifact); - - if (status.isRight()) { - - log.debug("Failed to delete artifact {} of resource {}", artifactId, id); - - BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("Delete Artifact", artifactId, String.valueOf(status.right().value())); - return Either.right(status.right().value()); - } else { - - return Either.left(status.left().value()); - } - } - - public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) { - - Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, parentType); - EdgeLabelEnum edgeLabelEnum = triple.getLeft(); - - Either, TitanOperationStatus> foundArtifact = null; - Map resMap = new HashMap<>(); - foundArtifact = getArtifactByLabel(parentId, instanceId, edgeLabelEnum); - if (foundArtifact.isRight()) { - log.debug("Failed to find artifact in component {} with label {} ", parentId, edgeLabelEnum); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(foundArtifact.right().value())); - } - - resMap.putAll(foundArtifact.left().value()); - - return Either.left(resMap); - } - - /** - * @param parentId the id of the instance container - * @param instanceId the id of the instance of which to return its artifacts - * @return instance and instance deployment artifacts mapped by artifact label name - */ - public Either, StorageOperationStatus> getAllInstanceArtifacts(String parentId, String instanceId) { - Map resMap = new HashMap<>(); - Either, TitanOperationStatus> instArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INSTANCE_ARTIFACTS); - if (instArtifacts.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(instArtifacts.right().value())); - } - Either, TitanOperationStatus> deployInstArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - if (deployInstArtifacts.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deployInstArtifacts.right().value())); - } - resMap.putAll(instArtifacts.left().value()); - resMap.putAll(deployInstArtifacts.left().value()); - return Either.left(convertArtifactMapToArtifactDefinitionMap(resMap)); - } - - public Either, StorageOperationStatus> getArtifacts(String parentId) { - - Either, TitanOperationStatus> foundArtifact = null; - Map resMap = new HashMap<>(); - foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.ARTIFACTS); - if (foundArtifact.isLeft()) { - resMap.putAll(foundArtifact.left().value()); - - } - foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); - if (foundArtifact.isLeft()) { - resMap.putAll(foundArtifact.left().value()); - - } - foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.TOSCA_ARTIFACTS); - if (foundArtifact.isLeft()) { - resMap.putAll(foundArtifact.left().value()); - - } - - return Either.left(resMap); - - } - - public Either removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { - - Either artifactData = this.getArtifactById(id, artifactId); - if (artifactData.isRight()) { - log.debug("Failed to find artifact in component {} with id {} ", id, artifactId); - return Either.right(artifactData.right().value()); - } - ArtifactDataDefinition artifactDefinition = artifactData.left().value(); - boolean isMandatory = false; - if ((artifactDefinition.getMandatory() || artifactDefinition.getServiceApi()) && !deleteMandatoryArtifact) { - // return Either.left(artifactData.left().value()); - isMandatory = true; - } - - Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactDefinition.getArtifactGroupType(), type); - EdgeLabelEnum edgeLabelEnum = triple.getLeft(); - VertexTypeEnum vertexTypeEnum = triple.getRight(); - - if (!isMandatory) { - StorageOperationStatus status = deleteToscaDataElement(id, edgeLabelEnum, vertexTypeEnum, artifactDefinition.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL); - if (status != StorageOperationStatus.OK) - return Either.right(status); - } - - return Either.left(artifactData.left().value()); - - } - - public void updateUUID(ArtifactDataDefinition artifactData, String oldChecksum, String oldVesrion, boolean isUpdate, EdgeLabelEnum edgeLabel) { - if (oldVesrion == null || oldVesrion.isEmpty()) - oldVesrion = "0"; - - String currentChecksum = artifactData.getArtifactChecksum(); - - if (isUpdate) { - ArtifactTypeEnum type = ArtifactTypeEnum.findType(artifactData.getArtifactType()); - switch (type) { - case HEAT_ENV: - if (edgeLabel == EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS) { - generateUUID(artifactData, oldVesrion); - } else { - updateVersionAndDate(artifactData, oldVesrion); - } - break; - case HEAT: - case HEAT_NET: - case HEAT_VOL: - generateUUID(artifactData, oldVesrion); - break; - default: - if (oldChecksum == null || oldChecksum.isEmpty()) { - if (currentChecksum != null) { - generateUUID(artifactData, oldVesrion); - } - } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) { - generateUUID(artifactData, oldVesrion); - } - break; - } - } else { - if (oldChecksum == null || oldChecksum.isEmpty()) { - if (currentChecksum != null) { - generateUUID(artifactData, oldVesrion); - } - } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) { - generateUUID(artifactData, oldVesrion); - } - } - } - - // @TODO add implementation - - public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType) { - return null; - } - - public Either addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifactHeat, String componentId, NodeTypeEnum parentType, boolean failIfExist, String instanceId) { - artifactHeatEnv.setGeneratedFromId(artifactHeat.getUniqueId()); - return addArifactToComponent(artifactHeatEnv, componentId, parentType, failIfExist, instanceId); - } - - public Either getHeatArtifactByHeatEnvId(String parentId, ArtifactDefinition heatEnv, NodeTypeEnum parentType, String containerId, ComponentTypeEnum componentType) { - String id = heatEnv.getGeneratedFromId(); - ComponentTypeEnum compType; - switch (parentType) { - case ResourceInstance: - compType = ComponentTypeEnum.RESOURCE_INSTANCE; - break; - default: - compType = componentType; - } - return getArtifactById(parentId, id, compType, containerId); - } - - public Either updateHeatEnvArtifact(String id, ArtifactDefinition artifactEnvInfo, String artifactId, String newArtifactId, NodeTypeEnum type, String instanceId) { - - Either, TitanOperationStatus> artifactsEither = getArtifactByLabel(id, instanceId, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); - if (artifactsEither.isRight()) { - log.debug("Failed to find artifacts in component {} with id {} ", id, artifactsEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(artifactsEither.right().value())); - } - - Map artifacts = artifactsEither.left().value(); - List envList = artifacts.values().stream().filter(a -> a.getGeneratedFromId() != null && a.getGeneratedFromId().equals(artifactId)).collect(Collectors.toList()); - if (envList != null && !envList.isEmpty()) { - envList.forEach(a -> { - a.setGeneratedFromId(newArtifactId); - updateArtifactOnResource(a, id, a.getUniqueId(), type, instanceId); - - }); - - } - return Either.left(artifactEnvInfo); - } - - public Either updateHeatEnvPlaceholder(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type) { - return updateArtifactOnResource(artifactInfo, parentId, artifactInfo.getUniqueId(), type, null); - } - - - ///////////////////////////////////////////// private methods //////////////////////////////////////////////////// - - protected ArtifactDefinition convertArtifactDataToArtifactDefinition(ArtifactDefinition artifactInfo, ArtifactDataDefinition artifactDefResult) { - log.debug("The object returned after create property is {}", artifactDefResult); - - ArtifactDefinition propertyDefResult = new ArtifactDefinition(artifactDefResult); - if (artifactInfo != null) - propertyDefResult.setPayload(artifactInfo.getPayloadData()); - - List parameters = new ArrayList<>(); - /* - * StorageOperationStatus heatParametersOfNode = heatParametersOperation.getHeatParametersOfNode(NodeTypeEnum.ArtifactRef, artifactDefResult.getUniqueId().toString(), parameters); if ((heatParametersOfNode.equals(StorageOperationStatus.OK)) - * && !parameters.isEmpty()) { propertyDefResult.setHeatParameters(parameters); } - */ - return propertyDefResult; - } - - private ArtifactDataDefinition getInstanceArtifactByLabelAndId(String parentId, String id, String containerId, EdgeLabelEnum edgeLabelEnum) { - ArtifactDataDefinition foundArtifact = null; - Either, TitanOperationStatus> artifactsEither = getDataFromGraph(containerId, edgeLabelEnum); - if (artifactsEither.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, containerId, artifactsEither.right().value()); - return null; - } - - Map artifacts = artifactsEither.left().value(); - - MapArtifactDataDefinition artifactsPerInstance = artifacts.get(parentId); - if (artifactsPerInstance == null) { - log.debug("failed to fetch artifacts for instance {} in tosca element with id {}, error {}", parentId, containerId, artifactsEither.right().value()); - return null; - } - Optional op = artifactsPerInstance.getMapToscaDataDefinition().values().stream().filter(p -> p.getUniqueId().equals(id)).findAny(); - if (op.isPresent()) { - foundArtifact = op.get(); - } - return foundArtifact; - } - - private ArtifactDataDefinition getArtifactByLabelAndId(String parentId, String id, EdgeLabelEnum edgeLabelEnum) { - ArtifactDataDefinition foundArtifact = null; - Either, TitanOperationStatus> artifactsEither = getDataFromGraph(parentId, edgeLabelEnum); - if (artifactsEither.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value()); - return null; - } - - Map artifacts = artifactsEither.left().value(); - Optional op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(id)).findAny(); - if (op.isPresent()) { - foundArtifact = op.get(); - } - return foundArtifact; - } - - private Either, TitanOperationStatus> getArtifactByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { - Either, TitanOperationStatus> artifactsEither = getArtifactsDataByLabel(parentId, instanceId, edgeLabelEnum); - if (artifactsEither.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value()); - return Either.right(artifactsEither.right().value()); - } - Map artifactDataMap = artifactsEither.left().value(); - return Either.left(convertArtifactMapToArtifactDefinitionMap(artifactDataMap)); - } - - private Either, TitanOperationStatus> getArtifactsDataByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { - return edgeLabelEnum.isInstanceArtifactsLabel() ? getInstanceArtifactsByLabel(parentId, instanceId, edgeLabelEnum) : getDataFromGraph(parentId, edgeLabelEnum); - } - - private Map convertArtifactMapToArtifactDefinitionMap(Map artifactDataMap) { - Map artMap = new HashMap<>(); - if (artifactDataMap != null && !artifactDataMap.isEmpty()) { - artMap = artifactDataMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> convertArtifactDataToArtifactDefinition(null, e.getValue()))); - } - return artMap; - } - - private Either, TitanOperationStatus> getInstanceArtifactsByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) { - Either, TitanOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum); - if (resultEither.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, resultEither.right().value()); - return Either.right(resultEither.right().value()); - } - Map mapArtifacts = resultEither.left().value(); - MapArtifactDataDefinition artifactPerInstance = mapArtifacts.get(instanceId); - return artifactPerInstance != null ? Either.left(artifactPerInstance.getMapToscaDataDefinition()) : Either.left(new HashMap<>()); - } - - private Triple getEdgeLabelEnumFromArtifactGroupType(ArtifactGroupTypeEnum groupType, NodeTypeEnum nodeType) { - EdgeLabelEnum edgeLabelEnum; - VertexTypeEnum vertexTypeEnum; - Boolean isDeepElement = false; - /* - * if (nodeType == NodeTypeEnum.ResourceInstance) { edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; isDeepElement = true; } else { - */ - switch (groupType) { - case TOSCA: - edgeLabelEnum = EdgeLabelEnum.TOSCA_ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.TOSCA_ARTIFACTS; - break; - case DEPLOYMENT: - if (nodeType == NodeTypeEnum.ResourceInstance) { - edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; - isDeepElement = true; - } else { - edgeLabelEnum = EdgeLabelEnum.DEPLOYMENT_ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.DEPLOYMENT_ARTIFACTS; - } - break; - case SERVICE_API: - edgeLabelEnum = EdgeLabelEnum.SERVICE_API_ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.SERVICE_API_ARTIFACTS; - break; - default: - if (nodeType == NodeTypeEnum.ResourceInstance) { - edgeLabelEnum = EdgeLabelEnum.INSTANCE_ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.INSTANCE_ARTIFACTS; - isDeepElement = true; - } else { - edgeLabelEnum = EdgeLabelEnum.ARTIFACTS; - vertexTypeEnum = VertexTypeEnum.ARTIFACTS; - } - break; - } - // } - return new ImmutableTriple<>(edgeLabelEnum, isDeepElement, vertexTypeEnum); - - } - - public Either updateArtifactOnGraph(String componentId, ArtifactDefinition artifactInfo, NodeTypeEnum type, String artifactId, String instanceId, boolean isUpdate, boolean isDeletePlaceholder) { - Either res = null; - ArtifactDataDefinition artifactToUpdate = new ArtifactDataDefinition(artifactInfo); - ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType(); - - Triple triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type); - EdgeLabelEnum edgeLabelEnum = triple.getLeft(); - VertexTypeEnum vertexTypeEnum = triple.getRight(); - - Either isNeedToCloneEither = isCloneNeeded(componentId, edgeLabelEnum); - if (isNeedToCloneEither.isRight()) { - log.debug("Failed check is clone needed {}", componentId); - return Either.right(isNeedToCloneEither.right().value()); - - } - boolean isNeedToClone = isNeedToCloneEither.left().value(); - - if (artifactId == null || isNeedToClone) { - String uniqueId; - if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { - uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel()); - } else { - uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel()); - } - artifactToUpdate.setUniqueId(uniqueId); - if (!isDeletePlaceholder) - artifactToUpdate.setEsId(uniqueId); - } else - artifactToUpdate.setUniqueId(artifactId); - - Map artifacts = new HashMap<>(); - Map artifactInst = null; - if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { - - Either, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum); - - if (artifactsEither.isLeft() && artifactsEither.left().value() != null && !artifactsEither.left().value().isEmpty()) { - artifacts = artifactsEither.left().value(); - if (isNeedToClone && artifacts != null) { - artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); - } - } - } else { - - Either, TitanOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum); - if (artifactsEither.isLeft()) { - artifactInst = artifactsEither.left().value(); - if (isNeedToClone && artifactInst != null) { - artifactInst.values().forEach(ma -> ma.getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE))); - } - MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId); - if (artifatcsOnInstance != null) { - artifacts = artifatcsOnInstance.getMapToscaDataDefinition(); - } - } - } - String oldChecksum = null; - String oldVersion = null; - if (artifacts != null && artifacts.containsKey(artifactInfo.getArtifactLabel())) { - ArtifactDataDefinition oldArtifactData = artifacts.get(artifactInfo.getArtifactLabel()); - oldChecksum = oldArtifactData.getArtifactChecksum(); - oldVersion = oldArtifactData.getArtifactVersion(); - //duplicated flag didn't receive from UI, take from DB - artifactToUpdate.setDuplicated(oldArtifactData.getDuplicated()); - - if (isNeedToClone) - artifactToUpdate.setDuplicated(Boolean.FALSE); - else { - if (artifactToUpdate.getDuplicated()) { - String uniqueId = ""; - if(type != NodeTypeEnum.ResourceInstance) - uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel()); - else - uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel()); - - artifactToUpdate.setUniqueId(uniqueId); - if (!isDeletePlaceholder) - artifactToUpdate.setEsId(uniqueId); - artifactToUpdate.setDuplicated(Boolean.FALSE); - } - } - } - updateUUID(artifactToUpdate, oldChecksum, oldVersion, isUpdate, edgeLabelEnum); - - if (artifactInfo.getPayloadData() == null) { - if (!artifactToUpdate.getMandatory() || artifactToUpdate.getEsId() != null) { - artifactToUpdate.setEsId(artifactToUpdate.getUniqueId()); - } - } else { - if (artifactToUpdate.getEsId() == null) { - artifactToUpdate.setEsId(artifactToUpdate.getUniqueId()); - } - } - - StorageOperationStatus status = StorageOperationStatus.OK; - if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) { - List toscaDataList = new ArrayList<>(); - toscaDataList.add(artifactToUpdate); - - if (isNeedToClone && artifacts != null) { - artifacts.values().stream().filter(a -> !a.getArtifactLabel().equals(artifactToUpdate.getArtifactLabel())).forEach(toscaDataList::add); - } - status = updateToscaDataOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, JsonPresentationFields.ARTIFACT_LABEL); - } else { - List toscaDataList = new ArrayList<>(); - toscaDataList.add(artifactToUpdate); - List pathKeys = new ArrayList<>(); - pathKeys.add(instanceId); - if (isNeedToClone) { - MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId); - if (artifatcsOnInstance != null) { - artifacts = artifatcsOnInstance.getMapToscaDataDefinition(); - artifacts.put(artifactToUpdate.getArtifactLabel(), artifactToUpdate); - } - - for (Entry e : artifactInst.entrySet()) { - List toscaDataListPerInst = e.getValue().getMapToscaDataDefinition().values().stream().collect(Collectors.toList()); - List pathKeysPerInst = new ArrayList<>(); - pathKeysPerInst.add(e.getKey()); - status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.ARTIFACT_LABEL); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update atifacts group for instance {} in component {} edge type {} error {}", instanceId, componentId, edgeLabelEnum, status); - res = Either.right(status); - break; - } - } - } else { - status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, pathKeys, JsonPresentationFields.ARTIFACT_LABEL); - } - } - if (status == StorageOperationStatus.OK) - res = Either.left(artifactToUpdate); - else - res = Either.right(status); - return res; - } - - public void generateUUID(ArtifactDataDefinition artifactData, String oldVesrion) { - - UUID uuid = UUID.randomUUID(); - artifactData.setArtifactUUID(uuid.toString()); - MDC.put("serviceInstanceID", uuid.toString()); - updateVersionAndDate(artifactData, oldVesrion); - } - - private void updateVersionAndDate(ArtifactDataDefinition artifactData, String oldVesrion) { - if (artifactData.getArtifactChecksum() != null) { - long time = System.currentTimeMillis(); - artifactData.setPayloadUpdateDate(time); - } - int newVersion = new Integer(oldVesrion).intValue(); - newVersion++; - artifactData.setArtifactVersion(String.valueOf(newVersion)); - } - - public Either removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { - - Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type); - EdgeLabelEnum edgeLabelEnum = triple.getLeft(); - VertexTypeEnum vertexTypeEnum = triple.getRight(); - - if (deleteMandatoryArtifact || !(artifactFromGraph.getMandatory() || artifactFromGraph.getServiceApi())) { - StorageOperationStatus status; - if (triple.getMiddle()) { - List pathKeys = new ArrayList<>(); - pathKeys.add(instanceId); - status = deleteToscaDataDeepElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), pathKeys, JsonPresentationFields.ARTIFACT_LABEL); - } else { - status = deleteToscaDataElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL); - } - if (status != StorageOperationStatus.OK) - return Either.right(status); - } - return Either.left(artifactFromGraph); - - } - - public Either deleteArtifactWithCloningOnGraph(String componentId, ArtifactDefinition artifactToDelete, NodeTypeEnum type, String instanceId, boolean deleteMandatoryArtifact) { - - Either result = null; - Triple triple = getEdgeLabelEnumFromArtifactGroupType(artifactToDelete.getArtifactGroupType(), type); - EdgeLabelEnum edgeLabel = triple.getLeft(); - VertexTypeEnum vertexLabel = triple.getRight(); - - Boolean deleteElement = deleteMandatoryArtifact || !(artifactToDelete.getMandatory() || artifactToDelete.getServiceApi()); - Map artifacts = null; - GraphVertex parentVertex = null; - Either, TitanOperationStatus> getArtifactsRes = null; - - Either getToscaElementRes = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", componentId, getToscaElementRes.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value())); - } - if (result == null) { - parentVertex = getToscaElementRes.left().value(); - getArtifactsRes = this.getDataFromGraph(parentVertex, edgeLabel); - if (getArtifactsRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getArtifactsRes.right().value())); - } - } - if (result == null) { - artifacts = getArtifactsRes.left().value(); - if (triple.getMiddle()) { - artifacts.values().forEach(ma -> ((MapArtifactDataDefinition) ma).getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE))); - MapArtifactDataDefinition artifatcsOnInstance = (MapArtifactDataDefinition) artifacts.get(instanceId); - if (artifatcsOnInstance != null && deleteElement) { - artifatcsOnInstance.getMapToscaDataDefinition().remove(artifactToDelete.getArtifactLabel()); - } - } else { - if (deleteElement) { - artifacts.remove(artifactToDelete.getArtifactLabel()); - } - artifacts.values().stream().forEach(a -> ((ArtifactDataDefinition) a).setDuplicated(Boolean.TRUE)); - } - artifactToDelete.setDuplicated(Boolean.TRUE); - } - if (artifacts != null) { - TitanOperationStatus status = titanDao.deleteEdgeByDirection(parentVertex, Direction.OUT, edgeLabel); - if (status != TitanOperationStatus.OK) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } else if (MapUtils.isNotEmpty(artifacts)) { - Either associateResult = associateElementToData(parentVertex, vertexLabel, edgeLabel, artifacts); - if (associateResult.isRight()) { - result = Either.right(associateResult.right().value()); - } - } - } - if (result == null) { - result = Either.left(artifactToDelete); - } - return result; - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/BaseOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/BaseOperation.java deleted file mode 100644 index d44865c399..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/BaseOperation.java +++ /dev/null @@ -1,1495 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang.ObjectUtils; -import org.apache.commons.lang.StringUtils; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.commons.lang3.tuple.Pair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Property; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.apache.tinkerpop.gremlin.structure.VertexProperty; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.operations.StorageException; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.openecomp.sdc.be.dao.impl.HealingPipelineDao; - -import java.util.*; -import java.util.EnumMap; -import java.util.stream.Collectors; - -/** - * public abstract class BaseOperation provides base operation functionality and common fields - * - */ -public abstract class BaseOperation { - - private static final String FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS = "Failed remove tosca data vertex of the tosca element {} by label {}. Status is {}. "; - private static final String FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS = "Failed to get child vertex of the tosca element {} by label {}. Status is {}. "; - private static final String FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS = "Failed to get tosca element {} upon adding the properties. Status is {}. "; - private static final Logger log = Logger.getLogger(BaseOperation.class.getName()); - public static final String VF_MODULE = "org.openecomp.groups.VfModule"; - - @Autowired - protected TitanDao titanDao; - - @Autowired - protected NodeTypeOperation nodeTypeOperation; - - @Autowired - protected TopologyTemplateOperation topologyTemplateOperation; - -// @Autowired - protected HealingPipelineDao healingPipelineDao; - - public void setTitanDao(TitanDao titanDao) { - this.titanDao = titanDao; - } - /** - * Returns reference to appropriate toscaTemplateOperation - * - * @param componentType - * @return - */ - public ToscaElementOperation getToscaElementOperation(ComponentTypeEnum componentType) { - ToscaElementOperation operation; - switch (componentType) { - case SERVICE: - case RESOURCE: - operation = topologyTemplateOperation; - break; - default: - operation = nodeTypeOperation; - break; - } - return operation; - } - - /** - * Returns reference to appropriate toscaTemplateOperation - * - * @param toscaElementType - * @return - */ - public ToscaElementOperation getToscaElementOperation(ToscaElementTypeEnum toscaElementType) { - ToscaElementOperation operation; - switch (toscaElementType) { - case TOPOLOGY_TEMPLATE: - operation = topologyTemplateOperation; - break; - case NODE_TYPE: - operation = nodeTypeOperation; - break; - default: - operation = null; - break; - } - return operation; - } - - /** - * Returns reference to appropriate toscaTemplateOperation - * - * @param toscaElementType - * @return - */ - public ToscaElementOperation getToscaElementOperation(VertexTypeEnum toscaElementType) { - ToscaElementOperation operation; - switch (toscaElementType) { - case TOPOLOGY_TEMPLATE: - operation = topologyTemplateOperation; - break; - case NODE_TYPE: - operation = nodeTypeOperation; - break; - default: - operation = null; - break; - } - return operation; - } - /** - * Converts received vertex to User object - * - * @param ownerV - * @return - */ - public User convertToUser(Vertex ownerV) { - User owner = new User(); - owner.setUserId((String) ownerV.property(GraphPropertyEnum.USERID.getProperty()).value()); - VertexProperty property = ownerV.property(GraphPropertyEnum.ROLE.getProperty()); - if(property != null && property.isPresent() ){ - owner.setRole((String) property.value()); - } - - property = ownerV.property(GraphPropertyEnum.FIRST_NAME.getProperty()); - if(property != null && property.isPresent() ){ - owner.setFirstName((String) ownerV.property(GraphPropertyEnum.FIRST_NAME.getProperty()).value()); - } - - property = ownerV.property(GraphPropertyEnum.LAST_NAME.getProperty()); - if( property != null && property.isPresent() ){ - owner.setLastName((String) ownerV.property(GraphPropertyEnum.LAST_NAME.getProperty()).value()); - } - - property = ownerV.property(GraphPropertyEnum.EMAIL.getProperty()); - if( property != null && property.isPresent() ){ - owner.setEmail((String) ownerV.property(GraphPropertyEnum.EMAIL.getProperty()).value()); - } - - property = ownerV.property(GraphPropertyEnum.LAST_LOGIN_TIME.getProperty()); - if( property != null && property.isPresent() ){ - owner.setLastLoginTime((Long) ownerV.property(GraphPropertyEnum.LAST_LOGIN_TIME.getProperty()).value()); - } - return owner; - } - - protected Either, TitanOperationStatus> getDataFromGraph(GraphVertex componentV, EdgeLabelEnum edgelabel) { - Either>, TitanOperationStatus> dataVertex = getDataAndVertexFromGraph(componentV, edgelabel); - if (dataVertex.isRight()) { - return Either.right(dataVertex.right().value()); - } - Map properties = dataVertex.left().value().getRight(); - return Either.left(properties); - } - - @SuppressWarnings("unchecked") - protected Either>, TitanOperationStatus> getDataAndVertexFromGraph(GraphVertex componentV, EdgeLabelEnum edgelabel) { - Either dataVertex = getDataVertex(componentV, edgelabel); - if (dataVertex.isRight()) { - return Either.right(dataVertex.right().value()); - } - GraphVertex propV = dataVertex.left().value(); - Map properties = (Map) propV.getJson(); - Pair> pair = new ImmutablePair<>(propV, properties); - return Either.left(pair); - } - - protected Either getDataVertex(GraphVertex componentV, EdgeLabelEnum edgelabel) { - Either childVertex = titanDao.getChildVertex(componentV, edgelabel, JsonParseFlagEnum.ParseJson); - if (childVertex.isRight()) { - if (childVertex.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("failed to fetch {} for tosca element with id {}, error {}", edgelabel, componentV.getUniqueId(), childVertex.right().value()); - } - return Either.right(childVertex.right().value()); - } - GraphVertex propV = childVertex.left().value(); - return Either.left(propV); - } - - /** - * Returns tosca data belonging to tosca element specified by uid according received label - * - * @param toscaElementUid - * @param edgelabel - * @return - */ - public Either, TitanOperationStatus> getDataFromGraph(String toscaElementUid, EdgeLabelEnum edgelabel) { - - Either, TitanOperationStatus> result = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", toscaElementUid, status); - result = Either.right(status); - } - if (result == null) { - result = getDataFromGraph(getToscaElementRes.left().value(), edgelabel); - } - return result; - } - - public Either findUserVertex(String userId) { - return titanDao.getVertexByPropertyAndLabel(GraphPropertyEnum.USERID, userId, VertexTypeEnum.USER, JsonParseFlagEnum.NoParse); - } - - /** - * - * @param elemementId - * @param label - * @return - */ - public Either isCloneNeeded(String elemementId, EdgeLabelEnum label) { - Either vertexById = titanDao.getVertexById(elemementId); - if (vertexById.isRight()) { - log.debug("Failed to fetch element by id {} error {}", elemementId, vertexById.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexById.right().value())); - } - GraphVertex toscaElementVertex = vertexById.left().value(); - Either childVertex = titanDao.getChildVertex(toscaElementVertex, label, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - if (childVertex.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("failed to fetch {} for tosca element with id {}, error {}", label, toscaElementVertex.getUniqueId(), childVertex.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childVertex.right().value())); - } - return Either.left(Boolean.FALSE); - } - GraphVertex dataVertex = childVertex.left().value(); - Iterator edges = dataVertex.getVertex().edges(Direction.IN, label.name()); - int edgeCount = 0; - while (edges.hasNext()) { - edges.next(); - ++edgeCount; - } - if (edgeCount > 1) { - return Either.left(Boolean.TRUE); - } else { - return Either.left(Boolean.FALSE); - } - } - - protected Either updateOrCopyOnUpdate(GraphVertex dataVertex, GraphVertex toscaElementVertex, EdgeLabelEnum label) { -// healingPipelineDao.setHealingVersion(dataVertex); - Iterator edges = dataVertex.getVertex().edges(Direction.IN, label.name()); - int edgeCount = 0; - Edge edgeToRemove = null; - while (edges.hasNext()) { - Edge edge = edges.next(); - ++edgeCount; - Vertex outVertex = edge.outVertex(); - String outId = (String) titanDao.getProperty((TitanVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()); - if (toscaElementVertex.getUniqueId().equals(outId)) { - edgeToRemove = edge; - } - } - if (edgeToRemove == null) { - log.debug("No edges {} from vertex {} to vertex {}", label, toscaElementVertex.getUniqueId(), dataVertex.getUniqueId()); - return Either.right(TitanOperationStatus.GENERAL_ERROR); - } - switch (edgeCount) { - case 0: - // error - log.debug("No edges {} to vertex {}", label, dataVertex.getUniqueId()); - return Either.right(TitanOperationStatus.GENERAL_ERROR); - case 1: - // update - log.trace("Only one edge {} to vertex {}. Update vertex", label, dataVertex.getUniqueId()); - return titanDao.updateVertex(dataVertex); - default: - // copy on update - log.trace("More than one edge {} to vertex {}. Need to clone vertex", label, dataVertex.getUniqueId()); - return cloneDataVertex(dataVertex, toscaElementVertex, label, edgeToRemove); - } - } - - private Either cloneDataVertex(GraphVertex dataVertex, GraphVertex toscaElementVertex, EdgeLabelEnum label, Edge edgeToRemove) { - GraphVertex newDataVertex = new GraphVertex(dataVertex.getLabel()); - String id = IdBuilderUtils.generateChildId(toscaElementVertex.getUniqueId(), dataVertex.getLabel()); - newDataVertex.cloneData(dataVertex); - newDataVertex.setUniqueId(id); - - Either createVertex = titanDao.createVertex(newDataVertex); - if (createVertex.isRight()) { - log.debug("Failed to clone data vertex for {} error {}", dataVertex.getUniqueId(), createVertex.right().value()); - return createVertex; - } - newDataVertex = createVertex.left().value(); - TitanOperationStatus createEdge = titanDao.createEdge(toscaElementVertex, newDataVertex, label, titanDao.getEdgeProperties(edgeToRemove)); - if (createEdge != TitanOperationStatus.OK) { - log.debug("Failed to associate vertex {} to vertex {}, error {}", toscaElementVertex.getUniqueId(), newDataVertex.getUniqueId(), createEdge); - return Either.right(createEdge); - } - edgeToRemove.remove(); - return Either.left(newDataVertex); - } - - public Either associateElementToData(GraphVertex element, VertexTypeEnum vertexLabel, EdgeLabelEnum edgeLabel, Map data) { - GraphVertex dataV = new GraphVertex(vertexLabel); - String id = IdBuilderUtils.generateChildId(element.getUniqueId(), vertexLabel); - dataV.setUniqueId(id); - dataV.setJson(data); - Either createVertex = titanDao.createVertex(dataV); - if (createVertex.isRight()) { - log.trace("Failed to create {} vertex for type node {}", vertexLabel, element.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createVertex.right().value())); - } - dataV = createVertex.left().value(); - TitanOperationStatus createEdgeStatus = titanDao.createEdge(element.getVertex(), dataV.getVertex(), edgeLabel, new HashMap<>()); - if (createEdgeStatus != TitanOperationStatus.OK) { - log.trace("Failed to create {} vertex for type node {}", vertexLabel, element.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeStatus)); - } - return Either.left(dataV); - } - - /** - * Adds tosca data element to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return addToscaDataToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - - /** - * Adds tosca data deep element to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataDeepElementToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, - JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return addToscaDataDeepElementsToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - - /** - * Converts recieved map of tosca data deep elements to list and adds it to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataMap - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataDeepElementsToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaDataMap, List pathKeys, - JsonPresentationFields mapKeyField) { - - if (toscaDataMap != null) { - return addToscaDataDeepElementsToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataMap.values().stream().collect(Collectors.toList()), pathKeys, mapKeyField); - } - return StorageOperationStatus.OK; - } - - /** - * Adds list of tosca data deep elements to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataDeepElementsToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, - JsonPresentationFields mapKeyField) { - - return updateOrAddToscaDataDeepElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField, false); - } - - /** - * Updates list of tosca data elements of tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return updateToscaDataOfToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - - /** - * Updates tosca data deep element of tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataDeepElementOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, - JsonPresentationFields mapKeyField) { - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return updateToscaDataDeepElementsOfToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - - /** - * Updates tosca data deep elements of tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataDeepElementsOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, - JsonPresentationFields mapKeyField) { - - return updateOrAddToscaDataDeepElement(toscaElement, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField, true); - } - - /** - * Adds tosca data element to tosca element with specified uid according received labels - * - * @param toscaElementUid - * @param toscaData - * @param edgeLabel - * @param vertexLabel - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return addToscaDataToToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - - /** - * Adds tosca data deep element to tosca element with specified uid according received labels - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataDeepElementToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, - JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return addToscaDataDeepElementsToToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - - public StorageOperationStatus updateToscaDataDeepElementOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, List pathKeys, - JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return updateToscaDataDeepElementsOfToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - - public StorageOperationStatus updateToscaDataDeepElementsOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, - JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { - statusRes = updateToscaDataDeepElementsOfToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - StorageOperationStatus overrideToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, Map toscaData) { - return titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse) - .left() - .bind(graphVertex -> overrideToscaElementData(graphVertex, toscaData, edgeLabel)) - .either(graphVertex -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - private Either overrideToscaElementData(GraphVertex toscaElement, Map toscaData, EdgeLabelEnum edgeLabelEnum) { - return titanDao.getChildVertex(toscaElement, edgeLabelEnum, JsonParseFlagEnum.ParseJson) - .left() - .bind(dataVertex -> overrideToscaElementData(dataVertex, toscaElement, toscaData, edgeLabelEnum)) - .right() - .map(err -> logAndReturn(err, "failed to override tosca data for element {} of type {}. status: {}", toscaElement.getUniqueId(), edgeLabelEnum, err)); - } - - private Either overrideToscaElementData(GraphVertex dataElement, GraphVertex toscaElement, Map toscaData, EdgeLabelEnum edgeLabelEnum) { - dataElement.setJson(toscaData); - return updateOrCopyOnUpdate(dataElement, toscaElement, edgeLabelEnum); - } - - /** - * Adds list of tosca data deep elements to tosca element with specified uid according received labels - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataDeepElementsToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, - JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { - statusRes = addToscaDataDeepElementsToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, pathKeys, mapKeyField); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - public StorageOperationStatus deleteToscaDataDeepElementsBlockOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String key) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null) { - statusRes = deleteToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, key); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - public StorageOperationStatus deleteToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String key) { - - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight()) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - toscaDataVertex = toscaDataVertexRes.left().value(); - result = deleteDeepElementsBlock(toscaDataVertex, key); - } - if (result == null) { - Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); - if (updateOrCopyRes.isRight()) { - TitanOperationStatus status = updateOrCopyRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca data block {} from the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - @SuppressWarnings("rawtypes") - public StorageOperationStatus addToscaDataDeepElementsBlockToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, MapDataDefinition toscaDataMap, String key) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null && toscaDataMap != null) { - statusRes = addToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataMap, key); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - @SuppressWarnings("rawtypes") - public StorageOperationStatus addToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, MapDataDefinition toscaDataMap, String key) { - - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null && toscaDataVertexRes.isLeft()) { - toscaDataVertex = toscaDataVertexRes.left().value(); - result = addDeepElementsBlock(toscaDataVertex, toscaDataMap, key); - - } - if (result == null) { - if (toscaDataVertex != null) { - Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); - if (updateOrCopyRes.isRight()) { - TitanOperationStatus status = updateOrCopyRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data {} to the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } else { - Map data = new HashMap<>(); - data.put(key, toscaDataMap); - Either createRes = associateElementToData(toscaElement, vertexLabel, edgeLabel, data); - if (createRes.isRight()) { - StorageOperationStatus status = createRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to assosiate tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); - result = status; - } - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - /** - * - * @param toscaElementId the id of the tosca element data container - * @param edgeLabel the edge label of the data type to update - * @param toscaDataMap the data to update - * @param key the key in the json object where the map object block resides - * @return the status of the update operation - */ - public StorageOperationStatus updateToscaDataDeepElementsBlockToToscaElement(String toscaElementId, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { - return titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse) - .either(toscaElement -> updateToscaDataDeepElementsBlockToToscaElement(toscaElement, edgeLabel, toscaDataMap, key), - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - private StorageOperationStatus updateToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { - return titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson) - .left() - .bind(dataVertex -> updateToscaDataDeepElementsBlockToToscaElement(toscaElement, dataVertex, edgeLabel, toscaDataMap, key)) - .either(updatedVertex -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - private Either updateToscaDataDeepElementsBlockToToscaElement(GraphVertex toscaElement, GraphVertex dataElement, EdgeLabelEnum edgeLabel, MapDataDefinition toscaDataMap, String key) { - Map mapToscaDataDefinition = toscaDataMap.getMapToscaDataDefinition(); - updateDeepElements(dataElement, mapToscaDataDefinition, Collections.singletonList(key)); - return updateOrCopyOnUpdate(dataElement, toscaElement, edgeLabel) - .right() - .map(err -> logAndReturn(err, "failed while trying to update data vertex from tosca element {}, of type {} . status {}", toscaElement.getUniqueId(), edgeLabel, err)); - } - - /** - * Updates tosca data element of tosca element by specified uid according received labels - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param toscaData - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, T toscaData, JsonPresentationFields mapKeyField) { - - List toscaDataList = new ArrayList<>(); - toscaDataList.add(toscaData); - return updateToscaDataOfToscaElement(toscaElementUid, edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - - /** - * Updates list of tosca data elements belonging to tosca element with specified uid according received labels - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataOfToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { - statusRes = updateToscaDataOfToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - /** - * Adds list of tosca data elements to tosca element with specified uid according received labels - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataToToscaElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = null; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == null && CollectionUtils.isNotEmpty(toscaDataList)) { - statusRes = addToscaDataToToscaElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, toscaDataList, mapKeyField); - } - if (statusRes == null) { - statusRes = StorageOperationStatus.OK; - } - return statusRes; - } - - /** - * Converts recieved map of tosca data elements to list and adds it to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataMap - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaDataMap, JsonPresentationFields mapKeyField) { - - return addToscaDataToToscaElement(toscaElement, edgeLabel, vertexLabel, toscaDataMap.values().stream().collect(Collectors.toList()), mapKeyField); - } - - /** - * Adds list of tosca data elements to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param mapKeyField - * @return - */ - public StorageOperationStatus addToscaDataToToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { - - return updateOrAddToscaData(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField, false); - } - - /** - * Updates list of tosca data elements belonging to tosca element according received labels - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param toscaDataList - * @param mapKeyField - * @return - */ - public StorageOperationStatus updateToscaDataOfToscaElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField) { - - return updateOrAddToscaData(toscaElement, edgeLabel, vertexLabel, toscaDataList, mapKeyField, true); - } - - public boolean hasEdgeOfType(GraphVertex toscaElement, EdgeLabelEnum edgeLabel) { - Either vertex = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - return vertex.isLeft(); - } - - @SuppressWarnings("unchecked") - private StorageOperationStatus updateOrAddToscaData(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, JsonPresentationFields mapKeyField, boolean isUpdate) { - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Map existingToscaDataMap = null; - Either, StorageOperationStatus> validateRes = null; - Map mergedToscaDataMap; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - if (toscaDataVertexRes.isLeft()) { - toscaDataVertex = toscaDataVertexRes.left().value(); - existingToscaDataMap = (Map) toscaDataVertex.getJson(); - } - - validateRes = validateMergeToscaData(toscaElement, toscaDataList, mapKeyField, existingToscaDataMap, isUpdate); - if (validateRes.isRight()) { - result = validateRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed validate tosca data upon adding to tosca element {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); - } - } - if (result == null) { - mergedToscaDataMap = validateRes.left().value(); - result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, mergedToscaDataMap); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - - } - - @SuppressWarnings("unchecked") - public StorageOperationStatus updateFullToscaData(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, Map toscaData) { - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Map existingToscaDataMap = null; - - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - if (toscaDataVertexRes.isLeft()) { - toscaDataVertex = toscaDataVertexRes.left().value(); - existingToscaDataMap = (Map) toscaDataVertex.getJson(); - } - - - } - if (result == null) { - - result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, toscaData); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - private StorageOperationStatus updateOrAddToscaDataDeepElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List toscaDataList, List pathKeys, - JsonPresentationFields mapKeyField, boolean isUpdate) { - - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Map existingDeepElementsMap = null; - Either, StorageOperationStatus> validateRes = null; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight() && toscaDataVertexRes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - if (toscaDataVertexRes.isLeft()) { - toscaDataVertex = toscaDataVertexRes.left().value(); - existingDeepElementsMap = getDeepElements(toscaDataVertex, pathKeys); - } - validateRes = validateMergeToscaData(toscaElement, toscaDataList, mapKeyField, existingDeepElementsMap, isUpdate); - if (validateRes.isRight()) { - result = validateRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed validate tosca data upon adding to tosca element {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); - } - } - if (result == null) { - updateDeepElements(toscaDataVertex, validateRes.left().value(), pathKeys); - Map toscaDataToHandle; - if(toscaDataVertex == null){ - toscaDataToHandle = new HashMap<>(); - Map currMap = toscaDataToHandle; - for (int i = 1; i < pathKeys.size()-1; ++i) { - currMap.put(pathKeys.get(i), (K) new MapDataDefinition()); - currMap = (Map) ((MapDataDefinition) currMap).getMapToscaDataDefinition().get(pathKeys.get(i)); - } - toscaDataToHandle.put(pathKeys.get(pathKeys.size()-1), (K) new MapDataDefinition(validateRes.left().value())); - - } else { - toscaDataToHandle = (Map) toscaDataVertex.getJson(); - } - result = handleToscaData(toscaElement, vertexLabel, edgeLabel, toscaDataVertex, toscaDataToHandle); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - private void updateDeepElements(GraphVertex toscaDataVertex, Map mergedDeepElementMap, List pathKeys) { - - if (toscaDataVertex != null && MapUtils.isNotEmpty(mergedDeepElementMap)) { - Map currMap = (Map) toscaDataVertex.getJson(); - if(!currMap.containsKey(pathKeys.get(0))){ - currMap.put(pathKeys.get(0), new MapDataDefinition<>()); - } - MapDataDefinition currDeepElement = currMap.get(pathKeys.get(0)); - - for (int i = 1; i < pathKeys.size(); ++i) { - if(currDeepElement.findByKey(pathKeys.get(i)) == null){ - currDeepElement.put(pathKeys.get(i), new MapDataDefinition<>()); - } - currDeepElement = (MapDataDefinition) currDeepElement.findByKey(pathKeys.get(i)); - } - if(currDeepElement != null){ - for (Map.Entry elementEntry : mergedDeepElementMap.entrySet()) { - currDeepElement.put(elementEntry.getKey(), elementEntry.getValue()); - } - } - } - } - - @SuppressWarnings({ "unchecked", "rawtypes" }) - private Map getDeepElements(GraphVertex toscaDataVertex, List pathKeys) { - Map result = null; - Map currMap = (Map) toscaDataVertex.getJson(); - MapDataDefinition currDeepElement = (MapDataDefinition) currMap.get(pathKeys.get(0)); - for (int i = 1; i < pathKeys.size(); ++i) { - currDeepElement = (MapDataDefinition) currDeepElement.findByKey(pathKeys.get(i)); - } - if(currDeepElement != null){ - result = (Map) currDeepElement.getMapToscaDataDefinition(); - } - return result; - } - - @SuppressWarnings("unchecked") - private StorageOperationStatus addDeepElementsBlock(GraphVertex toscaDataVertex, T toscaDataBlock, String key) { - - StorageOperationStatus result = null; - Map currMap = (Map) toscaDataVertex.getJson(); - if (currMap.containsKey(key)) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add block of deep tosca data elements by label {}." + " The block element with the same key {} already exists. ", toscaDataVertex.getLabel(), key); - result = StorageOperationStatus.ENTITY_ALREADY_EXISTS; - } - if (result == null) { - currMap.put(key, toscaDataBlock); - } - return result; - } - - @SuppressWarnings("unchecked") - private StorageOperationStatus deleteDeepElementsBlock(GraphVertex toscaDataVertex, String key) { - - StorageOperationStatus result = null; - Map currMap = (Map) toscaDataVertex.getJson(); - if (!currMap.containsKey(key)) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete block of deep tosca data elements by label {}." + " The block element with the same key {} doesn't exist. ", toscaDataVertex.getLabel(), key); - result = StorageOperationStatus.NOT_FOUND; - } - if (result == null) { - currMap.remove(key); - } - return null; - } - - /** - * Removes tosca data vertex belonging to tosca element specified by uid according label - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @return - */ - public StorageOperationStatus removeToscaData(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { - - StorageOperationStatus statusRes = StorageOperationStatus.OK; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == StorageOperationStatus.OK) { - statusRes = removeToscaDataVertex(getToscaElementRes.left().value(), edgeLabel, vertexLabel); - } - return statusRes; - } - - /** - * Removes tosca data vertex belonging to tosca element according label - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @return - */ - public StorageOperationStatus removeToscaDataVertex(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { - StorageOperationStatus result = null; - GraphVertex toscaDataVertex = null; - Iterator edges = null; - int edgeCounter = 0; - Edge edge = null; - Edge edgeToDelete = null; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight()) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - toscaDataVertex = toscaDataVertexRes.left().value(); - edges = toscaDataVertex.getVertex().edges(Direction.IN); - if (edges == null || !edges.hasNext()) { - result = StorageOperationStatus.NOT_FOUND; - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, result); - } - } - if (result == null) { - if (edges!=null) { - while (edges.hasNext()) { - ++edgeCounter; - edge = edges.next(); - if (edge.outVertex().id().equals(toscaElement.getVertex().id())) { - edgeToDelete = edge; - break; - } - } - } - if (edgeToDelete == null) { - result = StorageOperationStatus.NOT_FOUND; - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_REMOVE_TOSCA_DATA_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, result); - } - } - if (result == null) { - if (edgeCounter > 1 && edgeToDelete!=null) { - edgeToDelete.remove(); - } else { - toscaDataVertex.getVertex().remove(); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - /** - * Deletes tosca data elements belonging to tosca element specified by uid according label - * - * @param toscaElementUid - * @param edgeLabel - * @param uniqueKeys - * @return - */ - public StorageOperationStatus deleteToscaDataElements(String toscaElementUid, EdgeLabelEnum edgeLabel, List uniqueKeys) { - - StorageOperationStatus statusRes = StorageOperationStatus.OK; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == StorageOperationStatus.OK) { - statusRes = deleteToscaDataElements(getToscaElementRes.left().value(), edgeLabel, uniqueKeys); - } - return statusRes; - } - - /** - * Deletes tosca data element belonging to tosca element specified by uid according label - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param uniqueKey - * @param mapKeyField - * @return - */ - public StorageOperationStatus deleteToscaDataElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = StorageOperationStatus.OK; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == StorageOperationStatus.OK) { - statusRes = deleteToscaDataElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, uniqueKey, mapKeyField); - } - return statusRes; - - } - - /** - * Deletes tosca data deep element belonging to tosca element specified by uid according label - * - * @param toscaElementUid - * @param edgeLabel - * @param vertexLabel - * @param uniqueKey - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus deleteToscaDataDeepElement(String toscaElementUid, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, List pathKeys, JsonPresentationFields mapKeyField) { - - StorageOperationStatus statusRes = StorageOperationStatus.OK; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(toscaElementUid, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_TOSCA_ELEMENT_UPON_ADDING_THE_PROPERTIES_STATUS_IS, toscaElementUid, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (statusRes == StorageOperationStatus.OK) { - statusRes = deleteToscaDataDeepElement(getToscaElementRes.left().value(), edgeLabel, vertexLabel, uniqueKey, pathKeys, mapKeyField); - } - return statusRes; - - } - - /** - * Deletes tosca data deep element belonging to tosca element according label - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param uniqueKey - * @param pathKeys - * @param mapKeyField - * @return - */ - public StorageOperationStatus deleteToscaDataDeepElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, List pathKeys, JsonPresentationFields mapKeyField) { - - List uniqueKeys = new ArrayList<>(); - uniqueKeys.add(uniqueKey); - return deleteToscaDataDeepElements(toscaElement, edgeLabel, vertexLabel, uniqueKeys, pathKeys, mapKeyField); - } - - public StorageOperationStatus deleteToscaDataDeepElements(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, List uniqueKeys, List pathKeys, JsonPresentationFields mapKeyField) { - - StorageOperationStatus result = null; - GraphVertex toscaDataVertex; - Map existingToscaDataMap = null; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight()) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - toscaDataVertex = toscaDataVertexRes.left().value(); - existingToscaDataMap = getDeepElements(toscaDataVertexRes.left().value(), pathKeys); - result = deleteElementsFromDataVertex(toscaElement, edgeLabel, uniqueKeys, toscaDataVertex, existingToscaDataMap); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus deleteElementsFromDataVertex(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, List uniqueKeys, GraphVertex toscaDataVertex, Map existingToscaDataMap) { - StorageOperationStatus result; - for (String uniqueKey : uniqueKeys) { - result = removeKeyFromDataVertex(uniqueKey, existingToscaDataMap); - if (result != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca data element of the tosca element {} by label {}. Status is {}. ", toscaElement.getUniqueId(), edgeLabel, result); - break; - } - } - result = updateToscaDataElement(toscaElement, edgeLabel, toscaDataVertex); - return result; - } - - /** - * Deletes tosca data element belonging to tosca element according label - * - * @param toscaElement - * @param edgeLabel - * @param vertexLabel - * @param uniqueKey - * @param mapKeyField - * @return - */ - public StorageOperationStatus deleteToscaDataElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel, String uniqueKey, JsonPresentationFields mapKeyField) { - - List uniqueKeys = new ArrayList<>(); - uniqueKeys.add(uniqueKey); - return deleteToscaDataElements(toscaElement, edgeLabel, uniqueKeys); - } - - @SuppressWarnings("unchecked") -/** - * Deletes tosca data elements belonging to tosca element according label - * @param toscaElement - * @param edgeLabel - * @param uniqueKeys - * @return - */ - public StorageOperationStatus deleteToscaDataElements(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, List uniqueKeys) { - StorageOperationStatus result = null; - GraphVertex toscaDataVertex; - Map existingToscaDataMap; - Either toscaDataVertexRes = titanDao.getChildVertex(toscaElement, edgeLabel, JsonParseFlagEnum.ParseJson); - if (toscaDataVertexRes.isRight()) { - TitanOperationStatus status = toscaDataVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_CHILD_VERTEX_OF_THE_TOSCA_ELEMENT_BY_LABEL_STATUS_IS, toscaElement.getUniqueId(), edgeLabel, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(toscaDataVertexRes.right().value()); - } - if (result == null) { - toscaDataVertex = toscaDataVertexRes.left().value(); - existingToscaDataMap = (Map) toscaDataVertex.getJson(); - result = deleteElementsFromDataVertex(toscaElement, edgeLabel, uniqueKeys, toscaDataVertex, existingToscaDataMap); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - /** - * Adds the map data entry to the graph vertex of the specified type, related with the specified edge to the component specified by ID - * @param componentId The uniqueId of the component - * @param vertexTypeEnum The type of the vertex - * @param edgeLabelEnum The type of the edge - * @param mapDataEntry The map data entry - * @param - * @return The status of the operation result - */ - public StorageOperationStatus addElementToComponent(String componentId, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map.Entry mapDataEntry){ - if(MapUtils.isNotEmpty(mapDataEntry.getValue().getMapToscaDataDefinition())) - return addToscaDataDeepElementsBlockToToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, mapDataEntry.getValue(), mapDataEntry.getKey()); - return StorageOperationStatus.OK; - } - - private StorageOperationStatus updateToscaDataElement(GraphVertex toscaElement, EdgeLabelEnum edgeLabel, GraphVertex toscaDataVertex) { - StorageOperationStatus result = StorageOperationStatus.OK; - Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); - if (updateOrCopyRes.isRight()) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(updateOrCopyRes.right().value()); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), result); - } - return result; - } - - private StorageOperationStatus removeKeyFromDataVertex(String uniqueKey, Map existingToscaDataMap) { - if (!existingToscaDataMap.containsKey(uniqueKey)) { - return StorageOperationStatus.NOT_FOUND; - } - existingToscaDataMap.remove(uniqueKey); - return StorageOperationStatus.OK; - } - - protected StorageOperationStatus handleToscaData(GraphVertex toscaElement, VertexTypeEnum vertexLabel, EdgeLabelEnum edgeLabel, GraphVertex toscaDataVertex, Map mergedToscaDataMap) { - - StorageOperationStatus result = StorageOperationStatus.OK; - if (toscaDataVertex == null) { - - Either createRes = associateElementToData(toscaElement, vertexLabel, edgeLabel, mergedToscaDataMap); - if (createRes.isRight()) { - StorageOperationStatus status = createRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to assosiate tosca data {} of the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); - result = status; - } - } else { - toscaDataVertex.setJson(mergedToscaDataMap); - Either updateOrCopyRes = updateOrCopyOnUpdate(toscaDataVertex, toscaElement, edgeLabel); - if (updateOrCopyRes.isRight()) { - TitanOperationStatus status = updateOrCopyRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data {} to the tosca element {}. Status is {}. ", edgeLabel, toscaElement.getUniqueId(), status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - return result; - } - - private Either, StorageOperationStatus> validateMergeToscaData(GraphVertex toscaElement, List toscaDataList, JsonPresentationFields mapKeyField, Map existingToscaDataMap, - boolean isUpdate) { - - Map mergedToscaDataMap = new HashMap<>(); - StorageOperationStatus status; - Either, StorageOperationStatus> result = Either.left(mergedToscaDataMap); - if (MapUtils.isNotEmpty(existingToscaDataMap)) { - mergedToscaDataMap.putAll(existingToscaDataMap); - } - for (T toscaDataElement : toscaDataList) { - status = handleToscaDataElement(toscaElement, mapKeyField, mergedToscaDataMap, toscaDataElement, isUpdate); - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - break; - } - } - return result; - } - - private StorageOperationStatus handleToscaDataElement(GraphVertex toscaElement, JsonPresentationFields mapKeyField, Map mergedToscaDataMap, T toscaDataElement, boolean isUpdate) { - - StorageOperationStatus status = StorageOperationStatus.OK; - String currKey = (String) toscaDataElement.getToscaPresentationValue(mapKeyField); - - if(StringUtils.isEmpty(currKey) && toscaDataElement instanceof ListDataDefinition) { - ToscaDataDefinition toscaDataDefinition = ((ListDataDefinition) toscaDataElement) - .getListToscaDataDefinition().get(0); - if(toscaDataDefinition != null) { - currKey = (String) toscaDataDefinition.getToscaPresentationValue(mapKeyField); - } - } - - if (StringUtils.isEmpty(currKey)) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data to tosca element {}. The key is empty. "); - status = StorageOperationStatus.BAD_REQUEST; - } else if (!isUpdate && mergedToscaDataMap.containsKey(currKey)) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add tosca data to tosca element {}. The element with the same key {} already exists. ", toscaElement.getUniqueId(), currKey); - status = StorageOperationStatus.BAD_REQUEST; - } - mergedToscaDataMap.put(currKey, toscaDataElement); - return status; - } - -// public StorageOperationStatus updateDataOnGraph(GraphVertex dataVertex) { -// Either updateVertex = titanDao.updateVertex(dataVertex); -// if (updateVertex.isRight()) { -// return DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertex.right().value()); -// } -// return StorageOperationStatus.OK; -// } - - protected GroupInstanceDataDefinition buildGroupInstanceDataDefinition(GroupDataDefinition group, ComponentInstanceDataDefinition componentInstance, Map instDeplArtifMap) { - - String componentInstanceName = componentInstance.getName(); - Long creationDate = System.currentTimeMillis(); - GroupInstanceDataDefinition groupInstance = new GroupInstanceDataDefinition(); - String groupUid = group.getUniqueId(); - - groupInstance.setGroupUid(groupUid); - groupInstance.setType(group.getType()); - groupInstance.setCustomizationUUID(generateCustomizationUUID()); - groupInstance.setCreationTime(creationDate); - groupInstance.setModificationTime(creationDate); - groupInstance.setName(buildGroupInstanceName(componentInstanceName, group.getName())); - groupInstance.setGroupName(group.getName()); - groupInstance.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(groupInstance.getName())); - groupInstance.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(componentInstance.getUniqueId(), groupUid, groupInstance.getNormalizedName())); - groupInstance.setArtifacts(group.getArtifacts()); - -// List fixedArtifactsUuid; -// List artifactsUuid = group.getArtifactsUuid(); -// if (instDeplArtifMap != null) { -// fixedArtifactsUuid = new ArrayList<>(); -// artifactsUuid.forEach(u -> { -// Optional findFirst = instDeplArtifMap.values().stream().filter(a -> u.equals(a.getUniqueId())).findFirst(); -// if (findFirst.isPresent()) { -// fixedArtifactsUuid.add(findFirst.get().getArtifactUUID()); -// } else { -// fixedArtifactsUuid.add(u); -// } -// }); -// } else { -// fixedArtifactsUuid = artifactsUuid; -// } - groupInstance.setArtifactsUuid(group.getArtifactsUuid()); - groupInstance.setProperties(group.getProperties()); - convertPropertiesToInstanceProperties(groupInstance.getProperties()); - groupInstance.setInvariantUUID(group.getInvariantUUID()); - groupInstance.setGroupUUID(group.getGroupUUID()); - groupInstance.setVersion(group.getVersion()); - - return groupInstance; - } - - - protected String buildGroupInstanceName(String instanceName, String groupName) { - return ValidationUtils.normalizeComponentInstanceName(instanceName) + ".." + groupName; - } - - protected String generateCustomizationUUID() { - return UUID.randomUUID().toString(); - } - - protected void convertPropertiesToInstanceProperties(List properties){ - properties.forEach(PropertyDataDefinition::convertPropertyDataToInstancePropertyData); - } - - private TitanOperationStatus logAndReturn(TitanOperationStatus titanOperationStatus, String logMsg, Object ... logParams) { - log.debug(logMsg, logParams); - return titanOperationStatus; - } - - protected GraphVertex throwStorageException(TitanOperationStatus status) { - throw new StorageException(status); - } - - public void setHealingPipelineDao(HealingPipelineDao healingPipelineDao) { - this.healingPipelineDao = healingPipelineDao; - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ByToscaNameDerivedNodeTypeResolver.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ByToscaNameDerivedNodeTypeResolver.java deleted file mode 100644 index 5748629584..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ByToscaNameDerivedNodeTypeResolver.java +++ /dev/null @@ -1,55 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.model.DerivedNodeTypeResolver; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -@Component("derived-resource-resolver") -public class ByToscaNameDerivedNodeTypeResolver implements DerivedNodeTypeResolver { - - @Autowired - private TitanDao titanDao; - - @Override - public Either, TitanOperationStatus> findDerivedResources(String parentResource) { - Map propertiesToMatch = new HashMap<>(); - propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - - propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, parentResource); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - return titanDao.getByCriteria(VertexTypeEnum.NODE_TYPE, propertiesToMatch, JsonParseFlagEnum.NoParse); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperation.java deleted file mode 100644 index 9d7f64c24a..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperation.java +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.commons.collections.MapUtils; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.CapabilityDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.operations.StorageException; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -@org.springframework.stereotype.Component("capabilities-operation") -public class CapabilitiesOperation extends BaseOperation { - private static final Logger LOGGER = LoggerFactory.getLogger(CapabilitiesOperation.class); - - public Either, StorageOperationStatus> addCapabilities(String componentId, - List capabilityDefinitions) { - return addOrUpdateCapabilities(componentId, capabilityDefinitions, false); - } - - public Either, StorageOperationStatus> updateCapabilities(String componentId, - List capabilityDefinitions) { - return addOrUpdateCapabilities(componentId, capabilityDefinitions, true); - } - - private Either, StorageOperationStatus> addOrUpdateCapabilities(String componentId, - List capabilityDefinitions, - boolean isUpdateAction) { - StorageOperationStatus statusRes = performUpdateToscaAction(isUpdateAction, - componentId, Collections.singletonList(convertToListCapabilityDataDefinition(capabilityDefinitions))); - if (!statusRes.equals(StorageOperationStatus.OK)) { - LOGGER.error("Failed to find the parent capability of capability type {}." + " status is {}", componentId, - statusRes); - return Either.right(statusRes); - } - return Either.left(capabilityDefinitions); - } - - public StorageOperationStatus deleteCapabilities(Component component, String capabilityIdToDelete) { - return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES, - Collections.singletonList(capabilityIdToDelete)); - } - - public StorageOperationStatus deleteCapabilityProperties(Component component, String capabilityPropIdToDelete) { - return deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.CAPABILITIES_PROPERTIES, - Collections.singletonList(capabilityPropIdToDelete)); - } - - private static ListCapabilityDataDefinition convertToListCapabilityDataDefinition(List capabilities) { - List capabilityDefinitions = new ArrayList<>(capabilities); - return new ListCapabilityDataDefinition(capabilityDefinitions); - } - - private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, String componentId, - List toscaDataList) { - if (isUpdate) { - return updateToscaDataOfToscaElement(componentId, EdgeLabelEnum.CAPABILITIES, - VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE); - } else { - return addToscaDataToToscaElement(componentId, EdgeLabelEnum.CAPABILITIES, - VertexTypeEnum.CAPABILITIES, toscaDataList, JsonPresentationFields.TYPE); - } - } - - private StorageOperationStatus createOrUpdateCapabilityProperties(String componentId, TopologyTemplate toscaElement, - Map propertiesMap) { - GraphVertex toscaElementV = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) - .left().on(this::throwStorageException); - Map capabilitiesProperties = toscaElement.getCapabilitiesProperties(); - if(MapUtils.isNotEmpty(capabilitiesProperties)) { - - capabilitiesProperties.forEach((key, val) -> { - Map mapToscaDataDefinition = val.getMapToscaDataDefinition(); - mapToscaDataDefinition.forEach((key1, val1) -> { - - propertiesMap.forEach((propKey, propVal) -> { - Map propValMapToscaDataDefinition = propVal.getMapToscaDataDefinition(); - propValMapToscaDataDefinition.forEach((propKey1, propVal1) -> { - if(propKey1.equals(key1) && val1.getUniqueId().equals(propVal1.getUniqueId())) { - ToscaDataDefinition.mergeDataMaps(mapToscaDataDefinition, propValMapToscaDataDefinition); - } - }); - }); - }); - }); - - ToscaDataDefinition.mergeDataMaps(propertiesMap, capabilitiesProperties); - } - - return topologyTemplateOperation.updateFullToscaData(toscaElementV, - EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, propertiesMap); - } - - public StorageOperationStatus createOrUpdateCapabilityProperties(String componentId, - Map propertiesMap) { - StorageOperationStatus propertiesStatusRes = null; - if(MapUtils.isNotEmpty(propertiesMap)) { - propertiesStatusRes = createOrUpdateCapabilityProperties(componentId, getTopologyTemplate(componentId), - propertiesMap); - } - - return propertiesStatusRes; - } - - private TopologyTemplate getTopologyTemplate(String componentId) { - return (TopologyTemplate)topologyTemplateOperation - .getToscaElement(componentId, getFilterComponentWithCapProperties()) - .left() - .on(this::throwStorageException); - } - private ComponentParametersView getFilterComponentWithCapProperties() { - ComponentParametersView filter = new ComponentParametersView(); - filter.setIgnoreCapabiltyProperties(false); - return filter; - } - - private ToscaElement throwStorageException(StorageOperationStatus status) { - throw new StorageException(status); - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CategoryOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CategoryOperation.java deleted file mode 100644 index 88f0ea3fd7..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/CategoryOperation.java +++ /dev/null @@ -1,91 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -@org.springframework.stereotype.Component("category-operation") -public class CategoryOperation extends BaseOperation{ - - private static final Logger log = Logger.getLogger(CategoryOperation.class.getName()); - - /** - * - * @param name - * @param type - * @return - */ - public Either getCategory(String name, VertexTypeEnum type) { - if (name != null) { - String categoryUid = UniqueIdBuilder.buildComponentCategoryUid(name, type); - Map props = new HashMap<>(); - props.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(name)); - Either, TitanOperationStatus> either = titanDao.getByCriteria(type, props); - - if (either.isRight()) { - TitanOperationStatus titanOperationStatus = either.right().value(); - log.debug("Problem while geting category with id {}. reason - {}", categoryUid, titanOperationStatus.name()); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { - return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND); - } else { - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - } - return Either.left(either.left().value().get(0)); - } else { - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - } - /** - * - * @param categoryV - * @param name - * @return - */ - public Either getSubCategoryForCategory(GraphVertex categoryV, String name ) { - Either, TitanOperationStatus> childrenVertecies = titanDao.getChildrenVertecies(categoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); - if ( childrenVertecies.isRight() ){ - log.debug("Failed to fetch children verticies for category {} error {}", categoryV.getUniqueId(), childrenVertecies.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenVertecies.right().value())); - } - for ( GraphVertex childV : childrenVertecies.left().value() ){ - if ( childV.getMetadataProperty(GraphPropertyEnum.NAME).equals(name) ){ - return Either.left(childV); - } - } - return Either.right(StorageOperationStatus.NOT_FOUND); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperation.java deleted file mode 100644 index 70cfc5d238..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperation.java +++ /dev/null @@ -1,297 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - - -import fj.data.Either; -import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs; -import org.openecomp.sdc.be.model.jsontitan.utils.IdMapper; -import org.openecomp.sdc.be.model.operations.impl.OperationUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -import java.util.*; - -import static java.util.Collections.emptyMap; - -/** - * Created by yavivi on 26/01/2018. - */ -@Component -public class ExternalReferencesOperation extends BaseOperation { - - @Autowired - private IdMapper idMapper; - - @Autowired - private OperationUtils operationUtils; - - - /** - * Constructor - */ - public ExternalReferencesOperation(TitanDao titanDao, NodeTypeOperation nto, TopologyTemplateOperation tto, IdMapper idMapper){ - this.titanDao = titanDao; - this.topologyTemplateOperation = tto; - this.nodeTypeOperation = nto; - this.idMapper = idMapper; - } - - public Either addExternalReferenceWithCommit(String serviceUuid, String componentInstanceName, String objectType, String reference) { - Either addResult = addExternalReference(serviceUuid, componentInstanceName, objectType, reference); - titanDao.commit(); - return addResult; - } - - public Either deleteExternalReferenceWithCommit(String serviceUuid, String componentInstanceName, String objectType, String reference) { - Either result = deleteExternalReference(serviceUuid, componentInstanceName, objectType, reference); - titanDao.commit(); - return result; - } - - public Either updateExternalReferenceWithCommit(String serviceVertexUuid, String componentInstanceName, String objectType, String oldRef, String newRef) { - Either updateResult = updateExternalReference(serviceVertexUuid, componentInstanceName, objectType, oldRef, newRef); - titanDao.commit(); - return updateResult; - } - - public Either addExternalReference(String assetUuid, String componentInstanceName, String objectType, String reference) { - - //Get Container vertex - Either vertexById = titanDao.getVertexById(assetUuid); - if (vertexById.isRight()){ - return Either.right(ActionStatus.RESOURCE_NOT_FOUND); - } - - GraphVertex serviceVertex = vertexById.left().value(); - - final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); - if (compInstanceUniqueId == null) { - return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); - } - - //Get the external references map vertex - final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - - //Check whether data vertex found - GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; - - //instanceId -> externalRefsMap - Map externalReferencesFullData; - if (externalRefsVertex == null) { - //External Refs vertex does not exist, create its map. - externalReferencesFullData = new HashMap<>(); - externalReferencesFullData.put(compInstanceUniqueId, new MapComponentInstanceExternalRefs()); - } else { - externalReferencesFullData = (Map) externalRefsVertex.getJson(); - externalReferencesFullData.computeIfAbsent(compInstanceUniqueId, k -> new MapComponentInstanceExternalRefs()); - } - - boolean isAdded = addExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, reference); - updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); - - return isAdded ? Either.left(reference) : Either.right(ActionStatus.EXT_REF_ALREADY_EXIST); - } - - public Either deleteExternalReference(String assetUuid, String componentInstanceName, String objectType, String reference){ - //Get Service vertex - Either vertexById = titanDao.getVertexById(assetUuid); - if (vertexById.isRight()){ - return Either.right(ActionStatus.RESOURCE_NOT_FOUND); - } - GraphVertex serviceVertex = vertexById.left().value(); - - final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); - if (compInstanceUniqueId == null) { - return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); - } - - //Get the external references map vertex - final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - - //Check whether data vertex found - GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; - boolean refDeleted = false; - if (externalRefsVertex != null) { - Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); - if (externalReferencesFullData != null) { - refDeleted = deleteExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, reference); - updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); - } - } - - if (refDeleted) { - return Either.left(reference); - } else { - return Either.right(ActionStatus.EXT_REF_NOT_FOUND); - } - } - - public Either updateExternalReference(String assetUuid, String componentInstanceName, String objectType, String oldRef, String newRef) { - //Get Service vertex - Either vertexById = titanDao.getVertexById(assetUuid); - if (vertexById.isRight()){ - return Either.right(ActionStatus.RESOURCE_NOT_FOUND); - } - - GraphVertex serviceVertex = vertexById.left().value(); - - //Map instance_name -> uuid - final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); - if (compInstanceUniqueId == null) { - return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); - } - - //Get the external references map vertex - final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - - //Check whether data vertex found - GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; - boolean refReplaced = false; - if (externalRefsVertex != null) { - Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); - if (externalReferencesFullData != null) { - refReplaced = updateExternalRef(externalReferencesFullData, compInstanceUniqueId, objectType, oldRef, newRef); - updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); - } - } - if (refReplaced) { - return Either.left(newRef); - } else { - return Either.right(ActionStatus.EXT_REF_NOT_FOUND); - } - } - - public Either>, ActionStatus> getExternalReferences(String assetUuid, String objectType) { - //Get Service vertex - Either vertexById = titanDao.getVertexById(assetUuid); - if (vertexById.isRight()){ - return Either.right(ActionStatus.RESOURCE_NOT_FOUND); - } - - GraphVertex serviceVertex = vertexById.left().value(); - - Map> result = new HashMap(); - - //Get the external references map vertex - final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - //Check whether data vertex found - GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; - if (externalRefsVertex != null) { - Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); - if (externalReferencesFullData != null) { - externalReferencesFullData.entrySet().forEach( - s -> { - List externalRefsByObjectType = externalReferencesFullData.get(s.getKey()).getExternalRefsByObjectType(objectType); - List refList = externalRefsByObjectType == null ? new ArrayList<>() : externalRefsByObjectType; - String key = idMapper.mapUniqueIdToComponentNameTo(s.getKey(), serviceVertex); - result.put(key, refList); - } - ); - return Either.left(result); - } - } - //No external References Node found on this asset - return Either.left(new HashMap<>()); - } - - public void addAllExternalReferences(String containerUniqueId, - String compInstanceUniqueId, - Map> instanceExternalReferences) { - - GraphVertex serviceVertex = titanDao.getVertexById(containerUniqueId) - .left() - .on(operationUtils::onTitanOperationFailure); - Either dataVertex = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - Map externalReferencesFullData; - if (dataVertex.isLeft()) { - externalReferencesFullData = (Map) dataVertex.left().value().getJson(); - } else { - externalReferencesFullData = new HashMap<>(); - } - externalReferencesFullData.put(compInstanceUniqueId, new MapComponentInstanceExternalRefs(instanceExternalReferences)); - updateFullToscaData(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, externalReferencesFullData); - } - - public Map> getAllExternalReferences(String containerUniqueId, - String compInstanceUniqueId) { - GraphVertex serviceVertex = titanDao.getVertexById(containerUniqueId) - .left() - .on(operationUtils::onTitanOperationFailure); - - Either dataVertex = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - if (dataVertex.isRight()) { - return new HashMap<>(); - } - GraphVertex externalRefsVertex = dataVertex.left().value(); - Map externalReferencesFullData = externalRefsVertex == null ? null : (Map) externalRefsVertex.getJson(); - if (externalReferencesFullData != null) { - return externalReferencesFullData - .getOrDefault(compInstanceUniqueId, new MapComponentInstanceExternalRefs()) - .getComponentInstanceExternalRefs(); - } - return emptyMap(); - } - - public Either, ActionStatus> getExternalReferences(String assetUuid, String componentInstanceName, String objectType) { - //Get Service vertex - Either vertexById = titanDao.getVertexById(assetUuid); - if (vertexById.isRight()){ - return Either.right(ActionStatus.RESOURCE_NOT_FOUND); - } - - GraphVertex serviceVertex = vertexById.left().value(); - final String compInstanceUniqueId = idMapper.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); - if (compInstanceUniqueId == null) { - return Either.right(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND); - } - - //Get the external references map vertex - final Either dataVertexResult = getDataVertex(serviceVertex, EdgeLabelEnum.EXTERNAL_REFS); - - //Check whether data vertex found - GraphVertex externalRefsVertex = dataVertexResult.isLeft() ? dataVertexResult.left().value() : null; - if (externalRefsVertex != null) { - Map externalReferencesFullData = (Map) externalRefsVertex.getJson(); - if (externalReferencesFullData != null) { - return Either.left(getExternalReferencesByObjectId(externalReferencesFullData, compInstanceUniqueId, objectType)); - } - } - - //No external References Node found on this asset - return Either.left(new LinkedList()); - } - - public IdMapper getIdMapper() { - return idMapper; - } - - public void setIdMapper(IdMapper idMapper) { - this.idMapper = idMapper; - } - - private List getExternalReferencesByObjectId(Map externalReferencesFullData, String componentInstanceId, String objectType) { - MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); - List externalRefsByObjectType = externalRefsMap.getExternalRefsByObjectType(objectType); - return externalRefsByObjectType != null ? externalRefsByObjectType : new LinkedList<>(); - } - - private boolean updateExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String oldRef, String newRef) { - MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); - return externalRefsMap.replaceExternalRef(objectType, oldRef, newRef); - } - - private boolean deleteExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String reference) { - MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); - return externalRefsMap.deleteExternalRef(objectType, reference); - } - - private boolean addExternalRef(Map externalReferencesFullData, String componentInstanceId, String objectType, String reference) { - MapComponentInstanceExternalRefs externalRefsMap = externalReferencesFullData.get(componentInstanceId); - return externalRefsMap.addExternalRef(objectType, reference); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ForwardingPathOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ForwardingPathOperation.java deleted file mode 100644 index 0d82b0f27d..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ForwardingPathOperation.java +++ /dev/null @@ -1,117 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.log.wrappers.Logger; - -import java.util.*; - -@org.springframework.stereotype.Component("forwarding-paths-operations") -public class ForwardingPathOperation extends BaseOperation { - private static final Logger log = Logger.getLogger(ForwardingPathOperation.class.getName()); - - - public Either, StorageOperationStatus> deleteForwardingPath(Service service, Set forwardingPathsToDelete) { - Either, StorageOperationStatus> result = null; - Either getComponentVertex; - StorageOperationStatus status = null; - - if (result == null) { - getComponentVertex = titanDao.getVertexById(service.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - } - if (result == null) { - - status = deleteToscaDataElements(service.getUniqueId(), EdgeLabelEnum.FORWARDING_PATH,new ArrayList<>(forwardingPathsToDelete)); - - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - - if (result == null) { - result = Either.left(forwardingPathsToDelete); - } - return result; - } - - public Either addForwardingPath(String serviceId, ForwardingPathDataDefinition currentPath) { - return addOrUpdateForwardingPath(false, serviceId, currentPath); - } - - public Either updateForwardingPath(String serviceId, ForwardingPathDataDefinition currentPath) { - return addOrUpdateForwardingPath(true, serviceId, currentPath); - } - - private Either addOrUpdateForwardingPath(boolean isUpdateAction, String serviceId, ForwardingPathDataDefinition currentPath) { - - StorageOperationStatus statusRes; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(serviceId, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(log, CommonUtility.LogLevelEnum.DEBUG, "Failed to get tosca element {} upon adding the properties. Status is {}. ", serviceId, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - return Either.right(statusRes); - } - GraphVertex serviceVertex = getToscaElementRes.left().value(); - if (!isUpdateAction){ - currentPath.setUniqueId(UUID.randomUUID().toString()); - } - statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, Arrays.asList(currentPath), JsonPresentationFields.FORWARDING_PATH); - { - if (!statusRes.equals(StorageOperationStatus.OK)) { - log.error("Failed to find the parent capability of capability type {}. status is {}", serviceId, statusRes); - return Either.right(statusRes); - } - return Either.left(currentPath); - } - - } - - - private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, GraphVertex graphVertex, List toscaDataList, JsonPresentationFields mapKeyField) { - if (isUpdate) { - return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.FORWARDING_PATH, VertexTypeEnum.FORWARDING_PATH, toscaDataList, JsonPresentationFields.UNIQUE_ID); - } else { - return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.FORWARDING_PATH, VertexTypeEnum.FORWARDING_PATH, toscaDataList, JsonPresentationFields.UNIQUE_ID); - } - } - -} - - - diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperation.java deleted file mode 100644 index b417f83b74..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperation.java +++ /dev/null @@ -1,395 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.commons.collections.MapUtils; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.*; -import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; -import org.openecomp.sdc.be.model.operations.StorageException; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Optional; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("groups-operation") -public class GroupsOperation extends BaseOperation { - - private static final Logger log = Logger.getLogger(GroupsOperation.class.getName()); - - public StorageOperationStatus deleteCalculatedCapabilitiesWithProperties(String componentId, List groupDefinitions) { - Optional error = groupDefinitions.stream().map(g->removeCalculatedCapabilityFromComponent(componentId, g.getUniqueId())).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - if(!error.isPresent()){ - Map extractCapabilityPropertiesFromGroups = ModelConverter.extractCapabilityPropertiesFromGroups(groupDefinitions, false); - error = extractCapabilityPropertiesFromGroups.keySet().stream().map(k->removeCalculatedCapabilityPropertiesFromComponent(componentId, k)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - } - if(error.isPresent()){ - return error.get(); - } - return StorageOperationStatus.OK; - } - - /** - * Adds the map of the calculated capabilities and the map of the calculated capabilities properties the the component on the graph - * @param componentId - * @param calculatedCapabilities - * @param calculatedCapabilitiesProperties - * @return status of the result the operation - */ - public StorageOperationStatus addCalculatedCapabilitiesWithProperties(String componentId, Map calculatedCapabilities, Map calculatedCapabilitiesProperties) { - - Optional error = calculatedCapabilities.entrySet().stream().map(e-> addElementToComponent(componentId, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - if(!error.isPresent()){ - error = calculatedCapabilitiesProperties.entrySet().stream().map(e->addCalculatedCapabilityPropertiesToComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - } - if(error.isPresent()){ - return error.get(); - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus updateCalculatedCapabilitiesWithProperties(String componentId, Map calculatedCapabilities, Map calculatedCapabilitiesProperties) { - - Optional error = calculatedCapabilities.entrySet().stream().map(e->updateCalculatedCapabilityOfComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - if(!error.isPresent()){ - error = calculatedCapabilitiesProperties.entrySet().stream().map(e->updateCalculatedCapabilityPropertiesOnComponent(componentId, e)).filter(status-> status!=StorageOperationStatus.OK).findFirst(); - } - if(error.isPresent()){ - return error.get(); - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus updateCalculatedCapabilityOfComponent(String componentId, Entry capabilities){ - if(MapUtils.isNotEmpty(capabilities.getValue().getMapToscaDataDefinition())) - return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAPABILITIES, capabilities.getValue(), capabilities.getKey()); - return StorageOperationStatus.OK; - } - - private StorageOperationStatus addCalculatedCapabilityPropertiesToComponent(String componentId, Entry properties){ - if(MapUtils.isNotEmpty(properties.getValue().getMapToscaDataDefinition())) - return addToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, properties.getValue(), properties.getKey()); - return StorageOperationStatus.OK; - } - - private StorageOperationStatus updateCalculatedCapabilityPropertiesOnComponent(String componentId, Entry properties){ - if(MapUtils.isNotEmpty(properties.getValue().getMapToscaDataDefinition())) - return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, properties.getValue(), properties.getKey()); - return StorageOperationStatus.OK; - } - - private StorageOperationStatus removeCalculatedCapabilityFromComponent(String componentId, String groupId){ - return deleteToscaDataDeepElementsBlockOfToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, groupId); - } - - private StorageOperationStatus removeCalculatedCapabilityPropertiesFromComponent(String componentId, String groupId){ - return deleteToscaDataDeepElementsBlockOfToscaElement(componentId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, groupId); - } - - - public Either, StorageOperationStatus> createGroups(Component component, Map groups) { - - Either, StorageOperationStatus> result = null; - Either getComponentVertex = null; - StorageOperationStatus status = null; - - getComponentVertex = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - status = topologyTemplateOperation.associateGroupsToComponent(getComponentVertex.left().value(), groups); - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - if (result == null) { - result = Either.left(ModelConverter.convertToGroupDefinitions(groups)); - } - return result; - } - - public Either, StorageOperationStatus> addGroups(Component component, List groups) { - Either, StorageOperationStatus> result = null; - Either getComponentVertex; - StorageOperationStatus status; - - getComponentVertex = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - status = addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groups, JsonPresentationFields.NAME); - - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - - if (result == null) { - Map mapGroup = groups.stream().collect(Collectors.toMap(GroupDataDefinition::getName, x->x)); - result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); - } - return result; - } - - public Either, StorageOperationStatus> deleteGroups(Component component, List groups) { - Either, StorageOperationStatus> result = null; - Either getComponentVertex = null; - StorageOperationStatus status = null; - - getComponentVertex = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - List groupName = groups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()); - status = deleteToscaDataElements(component.getUniqueId(), EdgeLabelEnum.GROUPS, groupName); - - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - - if (result == null) { - Map mapGroup = groups.stream().collect(Collectors.toMap( GroupDataDefinition::getName, x->x)); - result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); - } - return result; - } - - public Either, StorageOperationStatus> updateGroups(Component component, List groups, boolean promoteVersion) { - Either, StorageOperationStatus> result = null; - Either getComponentVertex = null; - StorageOperationStatus status = null; - - getComponentVertex = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - groups.forEach(gr -> { - updateVersion(promoteVersion, gr); - String groupUUID = UniqueIdBuilder.generateUUID(); - gr.setGroupUUID(groupUUID); - }); - - status = updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groups, JsonPresentationFields.NAME); - - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - - if (result == null) { - Map mapGroup = groups.stream().collect(Collectors.toMap( GroupDataDefinition::getName, x->x)); - result = Either.left(ModelConverter.convertToGroupDefinitions(mapGroup)); - } - return result; - } - - private void updateVersion(boolean promoteVersion, T group) { - if(promoteVersion) { - String version = group.getVersion(); - String newVersion = increaseMajorVersion(version); - group.setVersion(newVersion); - } - } - - public void updateGroupOnComponent(String componentId, GroupDefinition groupDefinition) { - GraphVertex componentVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata) - .left() - .on(this::onTitanError); - - StorageOperationStatus updateToscaResult = updateToscaDataOfToscaElement(componentVertex, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groupDefinition, - JsonPresentationFields.NAME); - - if (StorageOperationStatus.OK != updateToscaResult) { - throw new StorageException(updateToscaResult, groupDefinition.getUniqueId()); - } - - updateLastUpdateDate(componentVertex); - } - - private void updateLastUpdateDate(GraphVertex componentVertex) { - componentVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - titanDao.updateVertex(componentVertex) - .left() - .on(this::onTitanError); - } - - GraphVertex onTitanError(TitanOperationStatus titanOperationStatus) { - throw new StorageException( - DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); - } - - public Either, StorageOperationStatus> updateGroupPropertiesOnComponent(String componentId, GroupDefinition group, List newGroupProperties) { - - Either, StorageOperationStatus> result = null; - Either getComponentVertex = null; - GraphVertex componentVertex = null; - - getComponentVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); - if (getComponentVertex.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component {}. Status is {} ", componentId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - componentVertex = getComponentVertex.left().value(); - //update - List properties = group.getProperties(); - newGroupProperties.forEach(np -> { - Optional currentProp = properties.stream().filter(p -> p.getName().equals(np.getName())).findAny(); - if (currentProp.isPresent()) { - currentProp.get().setValue(np.getValue()); - } - }); - - StorageOperationStatus updateDataRes = updateToscaDataOfToscaElement(componentVertex, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, group, JsonPresentationFields.NAME); - if (updateDataRes != StorageOperationStatus.OK) { - log.debug("Failed to update properties for group {} error {}", group.getName(), updateDataRes); - result = Either.right(updateDataRes); - } - } - if (result == null) { - componentVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - Either updateRes = titanDao.updateVertex(componentVertex); - if (updateRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the component {}. Status is {} ", componentId, updateRes.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateRes.right().value())); - } - } - if (result == null) { - result = Either.left(newGroupProperties); - } - return result; - } - - /** - * The version of the group is an integer. In order to support BC, we might get a version in a float format. - * - * @param version - * @return - */ - private String increaseMajorVersion(String version) { - - String[] versionParts = version.split(ToscaElementLifecycleOperation.VERSION_DELIMITER_REGEXP); - Integer majorVersion = Integer.parseInt(versionParts[0]); - - majorVersion++; - - return String.valueOf(majorVersion); - - } - - public Either, StorageOperationStatus> updateGroupInstances(Component component, String instanceId, List updatedGroupInstances) { - - Either, StorageOperationStatus> result = null; - StorageOperationStatus status = null; - - Either getComponentVertex = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - if (result == null) { - List pathKeys = new ArrayList<>(); - pathKeys.add(instanceId); - status = updateToscaDataDeepElementsOfToscaElement(component.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, updatedGroupInstances, pathKeys, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } - if (result == null) { - result = Either.left(updatedGroupInstances); - } - return result; - } - - public Either updateGroup(Component component, GroupDefinition currentGroup) { - StorageOperationStatus status = updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroup, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update group {} of component {}. The status is}. ", currentGroup.getName(), component.getName(), status); - return Either.right(status); - } - return Either.left(currentGroup); - } - - public StorageOperationStatus deleteGroup(Component component, String currentGroupName) { - StorageOperationStatus status = deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroupName, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete group {} of component {}. The status is}. ", currentGroupName, component.getName(), status); - } - return status; - } - - public Either addGroup(Component component, GroupDefinition currentGroup) { - StorageOperationStatus status = addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, currentGroup, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update group {} of component {}. The status is}. ", currentGroup.getName(), component.getName(), status); - return Either.right(status); - } - return Either.left(currentGroup); - } - - public Either updateGroupInstancePropertyValuesOnGraph(String componentId, String instanceId, GroupInstance oldGroupInstance, List newProperties) { - - Either getComponentVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); - if (getComponentVertex.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component {}. Status is {} ", componentId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - - List propertiesOld = oldGroupInstance.getProperties(); - newProperties.forEach(np -> { - Optional prop = propertiesOld.stream().filter(p -> p.getName().equals(np.getName())).findFirst(); - if (prop.isPresent()) { - prop.get().setValue(np.getValue()); - } - }); - GroupInstanceDataDefinition groupInstanceDataDefinition = new GroupInstanceDataDefinition(oldGroupInstance); - List pathKeys = new ArrayList<>(); - pathKeys.add(instanceId); - StorageOperationStatus updateDataRes = updateToscaDataDeepElementOfToscaElement(componentId, EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, groupInstanceDataDefinition, pathKeys, JsonPresentationFields.NAME); - if (updateDataRes != StorageOperationStatus.OK) { - log.debug("Failed to update properties for group instance {} error {}", oldGroupInstance.getName(), updateDataRes); - return Either.right(updateDataRes); - } - return Either.left(oldGroupInstance); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InstancesOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InstancesOperation.java deleted file mode 100644 index 84814e4863..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InstancesOperation.java +++ /dev/null @@ -1,25 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -public class InstancesOperation extends BaseOperation { - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperation.java deleted file mode 100644 index b4433d1be0..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperation.java +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import org.apache.commons.collections.MapUtils; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.InterfaceDefinition; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; - -@org.springframework.stereotype.Component("interfaces-operation") -public class InterfaceOperation extends BaseOperation { - - public Either, StorageOperationStatus> addInterfaces(String componentId, - List interfaceDefinitions) { - return addOrUpdateInterfaces(false, componentId, interfaceDefinitions); - } - - private Either, StorageOperationStatus> addOrUpdateInterfaces(boolean isUpdateAction, - String componentId, List interfaceDefinitions) { - - List interfaceDataDefinitions = - interfaceDefinitions.stream().map(InterfaceDataDefinition::new).collect(Collectors.toList()); - StorageOperationStatus statusRes = - performUpdateToscaAction(isUpdateAction, componentId, interfaceDataDefinitions, EdgeLabelEnum.INTERFACE, - VertexTypeEnum.INTERFACE); - if (!statusRes.equals(StorageOperationStatus.OK)) { - return Either.right(statusRes); - } - return Either.left(interfaceDefinitions); - } - - private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, String componentId, - List toscaDataList, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexLabel) { - if (isUpdate) { - return updateToscaDataOfToscaElement(componentId, edgeLabel, vertexLabel, toscaDataList, - JsonPresentationFields.UNIQUE_ID); - } else { - return addToscaDataToToscaElement(componentId, edgeLabel, vertexLabel, toscaDataList, - JsonPresentationFields.UNIQUE_ID); - } - } - - public Either, StorageOperationStatus> updateInterfaces(String componentId, - List interfaceDefinitions) { - return addOrUpdateInterfaces(true, componentId, interfaceDefinitions); - } - - public Either deleteInterface(String componentId, String interfacesToDelete) { - - StorageOperationStatus statusRes = deleteToscaDataElements(componentId, EdgeLabelEnum.INTERFACE, - Collections.singletonList(interfacesToDelete)); - if (!statusRes.equals(StorageOperationStatus.OK)) { - return Either.right(statusRes); - } - - Either, TitanOperationStatus> componentEither = - getDataFromGraph(componentId, EdgeLabelEnum.INTERFACE); - if (componentEither.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(componentEither.right().value())); - } - - Map interfaceDataDefinitionMap = componentEither.left().value(); - if (MapUtils.isEmpty(interfaceDataDefinitionMap)) { - statusRes = removeToscaData(componentId, EdgeLabelEnum.INTERFACE, VertexTypeEnum.INTERFACE); - if (!statusRes.equals(StorageOperationStatus.OK)) { - return Either.right(statusRes); - } - } - - return Either.left(interfacesToDelete); - } - -} \ No newline at end of file diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeFilterOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeFilterOperation.java deleted file mode 100644 index 7b3076ae8b..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeFilterOperation.java +++ /dev/null @@ -1,175 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableSet; -import fj.data.Either; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.log.wrappers.Logger; - -@org.springframework.stereotype.Component("service-filter-operations") -public class NodeFilterOperation extends BaseOperation { - - private static Logger logger = Logger.getLogger(NodeFilterOperation.class); - - public Either, StorageOperationStatus> deleteNodeFilters(Service service, - Set componentInstanceIds) { - Either getComponentVertex; - Either getNodeFilterVertex; - StorageOperationStatus status; - - getComponentVertex = titanDao.getVertexById(service.getUniqueId(), JsonParseFlagEnum.NoParse); - if (getComponentVertex.isRight()) { - return Either.right( - DaoStatusConverter.convertTitanStatusToStorageStatus(getComponentVertex.right().value())); - } - - getNodeFilterVertex = - titanDao.getChildVertex(getComponentVertex.left().value(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, - JsonParseFlagEnum.NoParse); - if (getNodeFilterVertex.isLeft()) { - status = deleteToscaDataElements(service.getUniqueId(), EdgeLabelEnum.NODE_FILTER_TEMPLATE, - new ArrayList<>(componentInstanceIds)); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - - return Either.left(componentInstanceIds); - } - - - public Either deleteNodeFilter(Service service, String componentInstanceId) { - final Either, StorageOperationStatus> listStorageOperationStatusEither = - deleteNodeFilters(service, ImmutableSet.of(componentInstanceId)); - if (listStorageOperationStatusEither.isRight()) { - return Either.right(listStorageOperationStatusEither.right().value()); - } - return Either.left(componentInstanceId); - } - - - public Either createNodeFilter(String serviceId, - String componentInstanceId) { - CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition(); - return addOrUpdateNodeFilter(false, serviceId, componentInstanceId, nodeFilterDataDefinition); - } - - public Either deleteConstraint(String serviceId, - String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, int propertyIndex) { - ListDataDefinition properties = - nodeFilterDataDefinition.getProperties(); - properties.getListToscaDataDefinition().remove(propertyIndex); - nodeFilterDataDefinition.setProperties(properties); - return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); - } - - public Either addNewProperty(String serviceId, - String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, - RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) { - ListDataDefinition properties = - nodeFilterDataDefinition.getProperties(); - if (properties == null) { - properties = new ListDataDefinition<>(); - nodeFilterDataDefinition.setProperties(properties); - } - properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition); - nodeFilterDataDefinition.setProperties(properties); - return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); - } - - public Either updateProperties(String serviceId, - String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition, - List requirementNodeFilterPropertyDataDefinition) { - ListDataDefinition properties = - nodeFilterDataDefinition.getProperties(); - properties.getListToscaDataDefinition().clear(); - properties.getListToscaDataDefinition().addAll(requirementNodeFilterPropertyDataDefinition); - nodeFilterDataDefinition.setProperties(properties); - return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition); - } - - public Either updateNodeFilter(String serviceId, - String componentInstanceId, CINodeFilterDataDefinition ciNodeFilterDataDefinition) { - return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, ciNodeFilterDataDefinition); - } - - private Either addOrUpdateNodeFilter(boolean isUpdateAction, - String serviceId, String componentInstanceId, CINodeFilterDataDefinition ciNodeFilterDataDefinition) { - - StorageOperationStatus statusRes; - Either getToscaElementRes; - - getToscaElementRes = titanDao.getVertexById(serviceId, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - TitanOperationStatus status = getToscaElementRes.right().value(); - CommonUtility.addRecordToLog(logger, CommonUtility.LogLevelEnum.DEBUG, - "Failed to get tosca element {} upon adding the properties. Status is {}. ", serviceId, status); - statusRes = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - return Either.right(statusRes); - } - GraphVertex serviceVertex = getToscaElementRes.left().value(); - ciNodeFilterDataDefinition.setID(componentInstanceId); - statusRes = performUpdateToscaAction(isUpdateAction, serviceVertex, ImmutableList.of(ciNodeFilterDataDefinition)); - if (!statusRes.equals(StorageOperationStatus.OK)) { - titanDao.rollback(); - logger.error( - " Failed to perform tosca update for node filter in service {} , component instance {}. status is {}", - serviceId, componentInstanceId, statusRes); - return Either.right(statusRes); - } - titanDao.commit(); - return Either.left(ciNodeFilterDataDefinition); - - } - - - private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, GraphVertex graphVertex, - List toscaDataList) { - if (isUpdate) { - return updateToscaDataOfToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, - VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID); - } else { - return addToscaDataToToscaElement(graphVertex, EdgeLabelEnum.NODE_FILTER_TEMPLATE, - VertexTypeEnum.NODE_FILTER_TEMPLATE, toscaDataList, JsonPresentationFields.UNIQUE_ID); - } - } - -} - - - diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperation.java deleted file mode 100644 index de396b4c1a..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperation.java +++ /dev/null @@ -1,2400 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang.StringUtils; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.commons.lang3.tuple.Pair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.openecomp.sdc.be.config.BeEcompErrorManager; -import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.CapabilityDefinition; -import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentInstance; -import org.openecomp.sdc.be.model.ComponentInstanceInput; -import org.openecomp.sdc.be.model.ComponentInstanceProperty; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.GroupDefinition; -import org.openecomp.sdc.be.model.GroupInstance; -import org.openecomp.sdc.be.model.InputDefinition; -import org.openecomp.sdc.be.model.PropertyDefinition; -import org.openecomp.sdc.be.model.RelationshipImpl; -import org.openecomp.sdc.be.model.RelationshipInfo; -import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; -import org.openecomp.sdc.be.model.RequirementDefinition; -import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; -import org.openecomp.sdc.common.api.ArtifactTypeEnum; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; - -import java.io.IOException; -import java.util.*; -import java.util.Map.Entry; -import java.util.function.BiConsumer; -import java.util.function.BiPredicate; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("node-template-operation") -public class NodeTemplateOperation extends BaseOperation { - private static final String FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR = "Failed to fetch container vertex {} error {}"; - private static final String FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE = "Failed to update topology template {} with new component instance {}. "; - private static final String ARTIFACT_PLACEHOLDER_TYPE = "type"; - private static final String ARTIFACT_PLACEHOLDER_DISPLAY_NAME = "displayName"; - private static final Object ARTIFACT_PLACEHOLDER_DESCRIPTION = "description"; - public static final String HEAT_ENV_NAME = "heatEnv"; - public static final String HEAT_VF_ENV_NAME = "VfHeatEnv"; - public static final String HEAT_ENV_SUFFIX = "env"; - private static Integer defaultHeatTimeout; - public static final Integer NON_HEAT_TIMEOUT = 0; - - private static final Logger log = Logger.getLogger(NodeTemplateOperation.class.getName()); - - public NodeTemplateOperation() { - defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getDefaultHeatArtifactTimeoutMinutes(); - if ((defaultHeatTimeout == null) || (defaultHeatTimeout < 1)) { - defaultHeatTimeout = 60; - } - } - - public static Integer getDefaultHeatTimeout() { - return defaultHeatTimeout; - } - - public Either, StorageOperationStatus> addComponentInstanceToTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, String instanceNumberSuffix, ComponentInstance componentInstance, - boolean allowDeleted, User user) { - - Either, StorageOperationStatus> result = null; - Either addComponentInstanceRes = null; - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to create component instance {} in component {}", componentInstance, container.getUniqueId()); - ComponentInstanceDataDefinition componentInstanceData = null; - Either newInstanceNameRes = null; - - Either metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseJson); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - if (result == null) { - - newInstanceNameRes = buildValidateInstanceName(container, originToscaElement, componentInstance, instanceNumberSuffix); - if (newInstanceNameRes.isRight()) { - result = Either.right(newInstanceNameRes.right().value()); - } - } - if (result == null) { - componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), newInstanceNameRes.left().value(), true, originToscaElement); - - addComponentInstanceRes = addComponentInstanceToTopologyTemplate(container, originToscaElement, componentInstanceData, metadataVertex.left().value(), allowDeleted, user); - - if (addComponentInstanceRes.isRight()) { - StorageOperationStatus status = addComponentInstanceRes.right().value(); - if (status == StorageOperationStatus.NOT_FOUND) { - status = StorageOperationStatus.INVALID_ID; - } - result = Either.right(status); - } - if (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy) { - TopologyTemplate updatedContainer = addComponentInstanceRes.left().value(); - result = addServerCapAndReqToProxyServerInstance(updatedContainer, componentInstance, componentInstanceData); - if(result.isRight()) { - return result; - } - - result = addServiceInstancePropertiesToProxyServiceInstance(updatedContainer, componentInstance); - if(result.isRight()) { - return result; - } - - result = addServiceInstanceInputsToProxyServiceInstance(updatedContainer, componentInstance); - if(result.isRight()) { - return result; - } - - result = addServiceInstanceInterfacesToProxyServiceInstance(updatedContainer, componentInstance); - if(result.isRight()) { - return result; - } - - } - } - if (result == null) { - result = Either.left(new ImmutablePair<>(addComponentInstanceRes.left().value(), componentInstanceData.getUniqueId())); - } - return result; - } - - private Either, StorageOperationStatus> addServerCapAndReqToProxyServerInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance, - - ComponentInstanceDataDefinition componentInstanceData) { - - Either, StorageOperationStatus> result; - - Map calcCap = updatedContainer.getCalculatedCapabilities(); - Map calcReg = updatedContainer.getCalculatedRequirements(); - Map calcCapProp = updatedContainer.getCalculatedCapabilitiesProperties(); - - Map> additionalCap = componentInstance.getCapabilities(); - Map> additionalReq = componentInstance.getRequirements(); - - MapListCapabilityDataDefinition allCalculatedCap = calcCap == null || !calcCap.containsKey(componentInstanceData.getUniqueId()) ? new MapListCapabilityDataDefinition() : calcCap.get(componentInstanceData.getUniqueId()); - /******** capability ****************************/ - StorageOperationStatus status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, componentInstanceData.getUniqueId()); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); - return Either.right(status); - } - - if (additionalCap != null && !additionalCap.isEmpty()) { - - Map serverCap = additionalCap.entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, en -> new ListCapabilityDataDefinition(en.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())))); - - serverCap.entrySet().forEach(entryPerType -> - entryPerType.getValue().getListToscaDataDefinition().forEach(cap -> { - cap.addToPath(componentInstance.getUniqueId()); - allCalculatedCap.add(entryPerType.getKey(), cap); - })); - - - addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap, componentInstance.getUniqueId()); - - /******** capability property ****************************/ - status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, componentInstanceData.getUniqueId()); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty properties for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); - return Either.right(status); - } - - MapCapabilityProperty allCalculatedCapProp = calcCapProp == null || !calcCapProp.containsKey(componentInstanceData.getUniqueId()) ? new MapCapabilityProperty() : calcCapProp.get(componentInstanceData.getUniqueId()); - - additionalCap.forEach(new BiConsumer>() { - @Override - public void accept(String s, List caps) { - - if (caps != null && !caps.isEmpty()) { - - MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - - for (CapabilityDefinition cap : caps) { - List capPrps = cap.getProperties(); - if (capPrps != null) { - - for (ComponentInstanceProperty cip : capPrps) { - dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip)); - } - - StringBuilder sb = new StringBuilder(componentInstance.getUniqueId()); - sb.append(ModelConverter.CAP_PROP_DELIM); - - sb.append(cap.getOwnerId()); - - sb.append(ModelConverter.CAP_PROP_DELIM).append(s).append(ModelConverter.CAP_PROP_DELIM).append(cap.getName()); - allCalculatedCapProp.put(sb.toString(), dataToCreate); - } - } - - } - - } - }); - - addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, allCalculatedCapProp, componentInstance.getUniqueId()); - } - - /******** Requirements property ****************************/ - if (additionalReq != null && !additionalReq.isEmpty()) { - - MapListRequirementDataDefinition allCalculatedReq = calcReg == null || !calcReg.containsKey(componentInstanceData.getUniqueId()) ? new MapListRequirementDataDefinition() : calcReg.get(componentInstanceData.getUniqueId()); - status = deleteToscaDataDeepElementsBlockOfToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, componentInstanceData.getUniqueId()); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated Requirements for instance {} in container {}. error {] ", componentInstanceData.getUniqueId(), updatedContainer.getUniqueId(), status); - return Either.right(status); - } - - Map serverReq = additionalReq.entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, en -> new ListRequirementDataDefinition(en.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())))); - - serverReq.entrySet().forEach(entryPerType -> - entryPerType.getValue().getListToscaDataDefinition().forEach(cap -> { - cap.addToPath(componentInstance.getUniqueId()); - allCalculatedReq.add(entryPerType.getKey(), cap); - })); - - - addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq, componentInstance.getUniqueId()); - - } - - Either updatedComponentInstanceRes = topologyTemplateOperation.getToscaElement(updatedContainer.getUniqueId()); - if (updatedComponentInstanceRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with new component instance {}. ", updatedContainer.getName(), componentInstance.getName()); - result = Either.right(updatedComponentInstanceRes.right().value()); - } - result = Either.left(new ImmutablePair<>((TopologyTemplate) updatedComponentInstanceRes.left().value(), componentInstanceData.getUniqueId())); - return result; - } - - private Either buildValidateInstanceName(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance, String instanceNumberSuffix) { - - Either result = null; - String instanceName = componentInstance.getName(); - if (StringUtils.isEmpty(instanceName) || instanceName.equalsIgnoreCase(originToscaElement.getName()) || componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy) { - instanceName = buildComponentInstanceName(instanceNumberSuffix, instanceName); - } else if (!isUniqueInstanceName(container, componentInstance.getName())) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create component instance with name {} on component container {}. The instance with the same name already exists. ", componentInstance.getName(), container.getName()); - result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS); - } - if (result == null) { - result = Either.left(instanceName); - } - return result; - } - - private Either, StorageOperationStatus> addServiceInstancePropertiesToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { - - List propertiesList = componentInstance.getProperties(); - - if (propertiesList != null && !propertiesList.isEmpty()) { - Map propertiesMap = propertiesList.stream().map(PropertyDataDefinition::new) - .collect(Collectors.toMap( - PropertyDataDefinition::getName, i -> i)); - MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(propertiesMap); - Map instPropertiesMap = new HashMap<>(); - instPropertiesMap.put(componentInstance.getUniqueId(), instProperties); - updatedContainer.setInstProperties(instPropertiesMap); - Either getToscaElementRes = titanDao.getVertexById(updatedContainer.getUniqueId(), JsonParseFlagEnum.NoParse); - if(getToscaElementRes.isLeft()){ - deleteToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), EdgeLabelEnum.INST_PROPERTIES, - VertexTypeEnum.INST_PROPERTIES, componentInstance.getUniqueId()); - } - StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), - EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, instProperties, - componentInstance.getUniqueId()); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - - - } - return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); - } - - private Either, StorageOperationStatus> addServiceInstanceInputsToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { - - List inputsList = componentInstance.getInputs(); - - if (CollectionUtils.isNotEmpty(inputsList)) { - Map inputsMap = inputsList.stream().map( - PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, i -> i)); - MapPropertiesDataDefinition instInputs = new MapPropertiesDataDefinition(inputsMap); - Map instInputsMap = new HashMap<>(); - instInputsMap.put(componentInstance.getUniqueId(), instInputs); - updatedContainer.setInstInputs(instInputsMap); - - StorageOperationStatus status = - addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), - EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, instInputs, - componentInstance.getUniqueId()); - if(status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - - return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); - } - - private Either, StorageOperationStatus> addServiceInstanceInterfacesToProxyServiceInstance(TopologyTemplate updatedContainer, ComponentInstance componentInstance) { - Map interfaces = componentInstance.getInterfaces(); - - if(MapUtils.isNotEmpty(interfaces)){ - Map interfacesMap = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> (InterfaceDataDefinition) e.getValue())); - MapInterfaceDataDefinition instInterfaces = new MapInterfaceDataDefinition(interfacesMap); - - Map instInterfacesMap = new HashMap<>(); - instInterfacesMap.put(componentInstance.getUniqueId(), instInterfaces); - updatedContainer.setComponentInstInterfaces(instInterfacesMap); - - StorageOperationStatus status = - addToscaDataDeepElementsBlockToToscaElement(updatedContainer.getUniqueId(), - EdgeLabelEnum.INST_INTERFACES, VertexTypeEnum.INST_INTERFACES, instInterfaces, - componentInstance.getUniqueId()); - - if(status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - - return Either.left(new ImmutablePair<>(updatedContainer, componentInstance.getUniqueId())); - } - - public Either addComponentInstanceToTopologyTemplate( - TopologyTemplate container, ToscaElement originToscaElement, - ComponentInstanceDataDefinition componentInstance, GraphVertex metadataVertex, boolean allowDeleted, - User user) { - - Either result = null; - Either updateContainerComponentRes = null; - String containerComponentId = container.getUniqueId(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to create component instance {} in component {}", componentInstance, containerComponentId); - String instOriginComponentId = componentInstance.getComponentUid(); - Either updateElement = null; - - Boolean isDeleted = (Boolean) originToscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED); - - if (!allowDeleted && (isDeleted != null) && isDeleted) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance", instOriginComponentId); - result = Either.right(StorageOperationStatus.INVALID_ID); - } - Boolean isArchived = originToscaElement.isArchived(); - if ( isArchived != null && isArchived ){ - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create instance {}. Origin {} component is archived . ", componentInstance.getName(), originToscaElement.getName()); - result = Either.right(StorageOperationStatus.COMPONENT_IS_ARCHIVED); - } - - if (result == null) { - container.addComponentInstance(componentInstance); - metadataVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - topologyTemplateOperation.fillToscaElementVertexData(metadataVertex, container, JsonParseFlagEnum.ParseAll); - updateElement = titanDao.updateVertex(metadataVertex); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value())); - } - } - if (result == null) { - Either addToscaDataRes = addComponentInstanceToscaDataToContainerComponent(originToscaElement, componentInstance, updateElement.left().value(), user); - if (addToscaDataRes.isRight()) { - result = Either.right(addToscaDataRes.right().value()); - } - } - if (result == null) { - StorageOperationStatus createInstanceEdge = createInstanceEdge(metadataVertex, componentInstance); - result = createInstanceEdge == StorageOperationStatus.OK ? null : Either.right(createInstanceEdge); - } - - if (result == null) { - updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); - if (updateContainerComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with new component instance {}. ", container.getName(), componentInstance.getName()); - result = Either.right(updateContainerComponentRes.right().value()); - } - } - if (result == null) { - result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value()); - } - return result; - } - - public Either, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance) { - - Either, StorageOperationStatus> result = null; - Either updateContainerComponentRes = null; - - String containerComponentId = container.getUniqueId(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstance, containerComponentId); - ComponentInstanceDataDefinition componentInstanceData = null; - - Either metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), componentInstance.getName(), false, originToscaElement); - container.addComponentInstance(componentInstanceData); - metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll); - Either updateElement = titanDao.updateVertex(metadataVertex.left().value()); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value())); - } - } - if (result == null) { - updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); - if (updateContainerComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", container.getName(), componentInstance.getName()); - result = Either.right(updateContainerComponentRes.right().value()); - } - } - if (result == null) { - result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceData.getUniqueId())); - } - return result; - } - - public Either updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container, ComponentParametersView filter) { - - Either result = null; - Either updateContainerComponentRes = null; - - String containerComponentId = container.getUniqueId(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata of container component {}", containerComponentId); - - Either metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll); - Either updateElement = titanDao.updateVertex(metadataVertex.left().value()); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {}. ", container.getName()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value())); - } - } - if (result == null) { - updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId, filter); - if (updateContainerComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {}. ", container.getName()); - result = Either.right(updateContainerComponentRes.right().value()); - } - } - if (result == null) { - result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value()); - } - return result; - } - - public Either, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(TopologyTemplate container, String componentInstanceId) { - - Either, StorageOperationStatus> result = null; - Either updateContainerComponentRes = null; - - String containerComponentId = container.getUniqueId(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstanceId, containerComponentId); - - Either metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - GraphVertex containerV = null; - ComponentInstanceDataDefinition removedComponentInstance = null; - if (result == null) { - removedComponentInstance = container.getComponentInstances().remove(componentInstanceId); - containerV = metadataVertex.left().value(); - StorageOperationStatus status = removeRelationsOfInstance(container, componentInstanceId, containerV); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete relation for component instance {} in container. error {}", componentInstanceId, container.getUniqueId(), status); - result = Either.right(status); - } - - containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - topologyTemplateOperation.fillToscaElementVertexData(containerV, container, JsonParseFlagEnum.ParseAll); - Either updateElement = titanDao.updateVertex(containerV); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstanceId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value())); - } - } - if (result == null) { - StorageOperationStatus status = deleteComponentInstanceToscaDataFromContainerComponent(containerV, componentInstanceId); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete data for instance {} in container {}. error {] ", componentInstanceId, container.getUniqueId(), status); - return Either.right(status); - } - ComponentInstance componentInstance = new ComponentInstance(removedComponentInstance); - StorageOperationStatus createInstanceEdge = removeInstanceEdge(containerV, componentInstance); - result = createInstanceEdge == StorageOperationStatus.OK ? null : Either.right(createInstanceEdge); - } - if (result == null) { - updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId); - if (updateContainerComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} after deleting the component instance {}. ", container.getName(), componentInstanceId); - result = Either.right(updateContainerComponentRes.right().value()); - } - } - if (result == null) { - result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceId)); - } - return result; - } - - private StorageOperationStatus removeRelationsOfInstance(TopologyTemplate container, String ciToRemove, GraphVertex containerV) { - CompositionDataDefinition composition = container.getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()); - if (composition != null) { - Map relations = composition.getRelations(); - if (MapUtils.isNotEmpty(relations)) { - Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (capResult.isRight()) { - return capResult.right().value(); - - } - Map calculatedCapabilty = capResult.left().value().getRight(); - - Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (capFullResult.isRight()) { - return capFullResult.right().value(); - - } - Map fullFilledCapabilty = capFullResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (reqResult.isRight()) { - return reqResult.right().value(); - } - Map calculatedRequirement = reqResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (reqResult.isRight()) { - return reqResult.right().value(); - } - Map fullfilledRequirement = reqFullResult.left().value().getRight(); - - Iterator> iterator = relations.entrySet().iterator(); - while (iterator.hasNext()) { - Entry relation = iterator.next(); - RelationshipInstDataDefinition relationToDelete = relation.getValue(); - if (relationToDelete.getFromId().equals(ciToRemove) || relationToDelete.getToId().equals(ciToRemove)) { - iterator.remove(); - if (relationToDelete.getFromId().equals(ciToRemove)) { - updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, ciToRemove, relationToDelete, null); - updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, relationToDelete.getToId(), relationToDelete, null); - } - if (relationToDelete.getToId().equals(ciToRemove)) { - updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, relationToDelete.getFromId(), relationToDelete, null); - updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, ciToRemove, relationToDelete, null); - } - } - } - return updateAllAndCalculatedCapReqOnGraph(container.getUniqueId(), containerV, capResult, capFullResult, reqResult, reqFullResult); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus deleteComponentInstanceToscaDataFromContainerComponent(GraphVertex containerV, String componentInstanceId) { - StorageOperationStatus status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove calculated requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled capabilities for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove attributes for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance inputs for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance deployment artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INSTANCE_ARTIFACTS, VertexTypeEnum.INSTANCE_ARTIFACTS, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.EXTERNAL_REFS, VertexTypeEnum.EXTERNAL_REF, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to remove instance external refs for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_INTERFACES, - VertexTypeEnum.INST_INTERFACES, componentInstanceId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, - "Failed to remove service instance interfaces for instance {} in container {}. " + - "error {] ", componentInstanceId, containerV.getUniqueId(), status); - return status; - } - return StorageOperationStatus.OK; - } - - protected Either addComponentInstanceToscaDataToContainerComponent(ToscaElement originToscaElement, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex, User user) { - - Either result; - StorageOperationStatus status; - if (originToscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) { - status = addComponentInstanceToscaDataToNodeTypeContainer((NodeType) originToscaElement, componentInstance, updatedContainerVertex); - } else { - status = addComponentInstanceToscaDataToTopologyTemplateContainer((TopologyTemplate) originToscaElement, componentInstance, updatedContainerVertex); - } - if (status == StorageOperationStatus.OK) { - result = Either.left(updatedContainerVertex); - } else { - result = Either.right(status); - } - return result; - } - - private StorageOperationStatus addComponentInstanceToscaDataToTopologyTemplateContainer(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { - - StorageOperationStatus status; - - status = addCalculatedCapReqFromTopologyTemplate(originTopologyTemplate, componentInstance, updatedContainerVertex); - - if (status != StorageOperationStatus.OK) { - - return status; - } - - MapPropertiesDataDefinition instInputs = new MapPropertiesDataDefinition(originTopologyTemplate.getInputs()); - MapPropertiesDataDefinition instInputsAsProperties = turnInputsIntoProperties(instInputs); - - status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, instInputsAsProperties, componentInstance.getUniqueId()); - if (status != StorageOperationStatus.OK) { - return status; - } - - return status; - } - - private MapPropertiesDataDefinition turnInputsIntoProperties(MapPropertiesDataDefinition instInput){ - if (instInput.getMapToscaDataDefinition() != null) { - for (PropertyDataDefinition currProp : instInput.getMapToscaDataDefinition().values()){ - String temp = currProp.getValue(); - currProp.setValue(currProp.getDefaultValue()); - currProp.setDefaultValue(temp); - } - } - return instInput; - } - - private MapListCapabilityDataDefinition prepareCalculatedCapabiltyForTopologyTemplate( - Map capabilities, - ComponentInstanceDataDefinition componentInstance, - MapListCapabilityDataDefinition calculatedCap) { - MapListCapabilityDataDefinition allCalculatedCap = - new MapListCapabilityDataDefinition(calculatedCap); - populateCapability(capabilities, componentInstance, allCalculatedCap); - return allCalculatedCap; - } - - private void populateCapability(Map capabilities, - ComponentInstanceDataDefinition componentInstance, - MapListCapabilityDataDefinition allCalculatedCap) { - capabilities.forEach((key, value) -> { - List listCapabilities = value.getListToscaDataDefinition() - .stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()); - listCapabilities.forEach(cap -> { - cap.setSource(componentInstance.getComponentUid()); - cap.addToPath(componentInstance.getUniqueId()); - cap.setOwnerId(componentInstance.getUniqueId()); - cap.setOwnerName(componentInstance.getName()); - cap.setLeftOccurrences(cap.getMaxOccurrences()); - allCalculatedCap.add(key, cap); - }); - }); - } - - private MapListRequirementDataDefinition prepareCalculatedRequirementForTopologyTemplate( - Map requirements, - ComponentInstanceDataDefinition componentInstance, - MapListRequirementDataDefinition calculatedReqs) { - MapListRequirementDataDefinition allCalculatedReq = - new MapListRequirementDataDefinition(calculatedReqs); - - populateRequirement(requirements, componentInstance, allCalculatedReq); - return allCalculatedReq; - } - private void populateRequirement(Map requirements, - ComponentInstanceDataDefinition componentInstance, - MapListRequirementDataDefinition allCalculatedReq) { - requirements.forEach((key, value) -> { - List listRequirements = value.getListToscaDataDefinition() - .stream().map(RequirementDataDefinition::new).collect(Collectors.toList()); - listRequirements.forEach(req -> { - req.setSource(componentInstance.getComponentUid()); - req.addToPath(componentInstance.getUniqueId()); - req.setOwnerId(componentInstance.getUniqueId()); - req.setOwnerName(componentInstance.getName()); - req.setLeftOccurrences(req.getMaxOccurrences()); - allCalculatedReq.add(key, req); - }); - }); - } - - - - private StorageOperationStatus addCalculatedCapReqFromTopologyTemplate(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { - Map calculatedCapabilities = originTopologyTemplate.getCalculatedCapabilities(); - - MapListCapabilityDataDefinition allCalculatedCap = new MapListCapabilityDataDefinition(); - if (calculatedCapabilities != null) { - calculatedCapabilities.forEach((key1, value1) -> { - Map mapByType = value1.getMapToscaDataDefinition(); - mapByType.forEach((key, value) -> value.getListToscaDataDefinition().forEach(cap -> { - cap.addToPath(componentInstance.getUniqueId()); - allCalculatedCap.add(key, cap); - })); - }); - } - MapListCapabilityDataDefinition allCaps; - Map capabilities = originTopologyTemplate.getCapabilities(); - if (MapUtils.isNotEmpty(capabilities)) { - allCaps = prepareCalculatedCapabiltyForTopologyTemplate(capabilities, componentInstance, - allCalculatedCap); - } else { - allCaps = new MapListCapabilityDataDefinition(allCalculatedCap); - } - if(!allCaps.isEmpty()) { - StorageOperationStatus calculatedCapabilitiesResult = - addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, - EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, - allCaps, componentInstance.getUniqueId()); - if (calculatedCapabilitiesResult != StorageOperationStatus.OK) { - return calculatedCapabilitiesResult; - } - MapListCapabilityDataDefinition fullCalculatedCap = new MapListCapabilityDataDefinition(); - calculatedCapabilitiesResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, - EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, - fullCalculatedCap, componentInstance.getUniqueId()); - if (calculatedCapabilitiesResult != StorageOperationStatus.OK) { - return calculatedCapabilitiesResult; - } - } - Map calculatedRequirements = - originTopologyTemplate.getCalculatedRequirements(); - MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition(); - if (calculatedRequirements != null) { - calculatedRequirements.forEach((key, value) -> { - Map mapByType = - value.getMapToscaDataDefinition(); - mapByType.forEach((key1, value1) -> value1.getListToscaDataDefinition().forEach(req -> { - req.addToPath(componentInstance.getUniqueId()); - allCalculatedReq.add(key1, req); - })); - }); - - } - - MapListRequirementDataDefinition allReqs; - Map requirements = originTopologyTemplate.getRequirements(); - if (MapUtils.isNotEmpty(requirements)) { - allReqs = prepareCalculatedRequirementForTopologyTemplate(requirements, - componentInstance, allCalculatedReq); - } else - allReqs = new MapListRequirementDataDefinition(allCalculatedReq); - - if(!allReqs.isEmpty()) { - StorageOperationStatus calculatedRequirementResult = - addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, - EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, - allReqs, componentInstance.getUniqueId()); - if (calculatedRequirementResult != StorageOperationStatus.OK) { - return calculatedRequirementResult; - } - MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition(); - calculatedRequirementResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, - EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, - fullCalculatedReq, - componentInstance.getUniqueId()); - if (calculatedRequirementResult != StorageOperationStatus.OK) { - return calculatedRequirementResult; - } - } - Map calculatedCapabilitiesProperties = originTopologyTemplate.getCalculatedCapabilitiesProperties(); - Map updateKeyMap = new HashMap<>(); - - if (calculatedCapabilitiesProperties != null && !calculatedCapabilitiesProperties.isEmpty()) { - for (MapCapabilityProperty map : calculatedCapabilitiesProperties.values()) { - for (Entry entry : map.getMapToscaDataDefinition().entrySet()) { - String newKey = (componentInstance.getUniqueId() + ModelConverter.CAP_PROP_DELIM + entry.getKey()); - updateKeyMap.put(newKey, entry.getValue()); - } - } - } - Map capabilitiesProperties = - originTopologyTemplate.getCapabilitiesProperties(); - Map updateKeyMapCapabilitiesProperties; - if (MapUtils.isNotEmpty(capabilitiesProperties)) { - updateKeyMapCapabilitiesProperties = capabilitiesProperties.entrySet().stream() - .collect(Collectors.toMap(e -> createCapPropertyKey(e.getKey(), - componentInstance.getUniqueId()), Entry::getValue)); - } - else { - updateKeyMapCapabilitiesProperties = new HashMap<>(); - } - updateKeyMap.putAll(updateKeyMapCapabilitiesProperties); - MapCapabilityProperty mapCapabilityProperty = new MapCapabilityProperty(updateKeyMap); - - if(MapUtils.isNotEmpty(capabilitiesProperties) || MapUtils.isNotEmpty(calculatedCapabilitiesProperties )) { - StorageOperationStatus calculatedResult = - addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, - EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, - VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabilityProperty, - componentInstance.getUniqueId()); - if (calculatedResult != StorageOperationStatus.OK) { - return calculatedResult; - } - } - return StorageOperationStatus.OK; - } - private StorageOperationStatus addComponentInstanceToscaDataToNodeTypeContainer(NodeType originNodeType, - ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { - - StorageOperationStatus status; - - if(MapUtils.isNotEmpty(originNodeType.getProperties())){ - MapPropertiesDataDefinition instProperties = - new MapPropertiesDataDefinition(originNodeType.getProperties()); - status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_PROPERTIES, - VertexTypeEnum.INST_PROPERTIES, instProperties, componentInstance.getUniqueId()); - if (status != StorageOperationStatus.OK) { - return status; - } - } - - if(MapUtils.isNotEmpty(originNodeType.getAttributes())){ - MapPropertiesDataDefinition instAttributes = - new MapPropertiesDataDefinition(originNodeType.getAttributes()); - status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_ATTRIBUTES, - VertexTypeEnum.INST_ATTRIBUTES, instAttributes, componentInstance.getUniqueId()); - if (status != StorageOperationStatus.OK) { - return status; - } - } - - return addCalculatedCapReqFromNodeType(originNodeType, componentInstance, updatedContainerVertex); - } - - public MapArtifactDataDefinition prepareInstDeploymentArtifactPerInstance(Map deploymentArtifacts, String componentInstanceId, User user, String envType) { - if (deploymentArtifacts != null && envType.equals(HEAT_VF_ENV_NAME)) { - Map instDeploymentArtifacts = new HashMap<>(); - - deploymentArtifacts.entrySet().forEach(e -> { - ArtifactDataDefinition artifact = e.getValue(); - String type = artifact.getArtifactType(); - if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) { - ArtifactDataDefinition artifactEnv = createArtifactPlaceHolderInfo(artifact, componentInstanceId, user, envType); - instDeploymentArtifacts.put(artifactEnv.getArtifactLabel(), artifactEnv); - } - }); - - deploymentArtifacts.putAll(instDeploymentArtifacts); - - return new MapArtifactDataDefinition(deploymentArtifacts); - - } - return null; - } - - @SuppressWarnings({ "unchecked" }) - private ArtifactDataDefinition createArtifactPlaceHolderInfo(ArtifactDataDefinition artifactHeat, String componentId, User user, String heatEnvType) { - Map deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getDeploymentResourceInstanceArtifacts(); - if (deploymentResourceArtifacts == null) { - log.debug("no deployment artifacts are configured for generated artifacts"); - return null; - } - Map placeHolderData = (Map) deploymentResourceArtifacts.get(heatEnvType); - if (placeHolderData == null) { - log.debug("no env type {} are configured for generated artifacts", heatEnvType); - return null; - } - - String envLabel = (artifactHeat.getArtifactLabel() + HEAT_ENV_SUFFIX).toLowerCase(); - - ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition(); - - String artifactName = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DISPLAY_NAME); - String artifactType = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_TYPE); - String artifactDescription = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DESCRIPTION); - - artifactInfo.setArtifactDisplayName(artifactName); - artifactInfo.setArtifactLabel(envLabel); - artifactInfo.setArtifactType(artifactType); - artifactInfo.setDescription(artifactDescription); - artifactInfo.setArtifactGroupType(artifactHeat.getArtifactGroupType()); - setDefaultArtifactTimeout(artifactHeat.getArtifactGroupType(), artifactInfo); - artifactInfo.setGeneratedFromId(artifactHeat.getUniqueId()); - // clone heat parameters in case of heat env only not VF heat env - if (heatEnvType.equals(HEAT_ENV_NAME)) { - artifactInfo.setHeatParameters(artifactHeat.getHeatParameters()); - } - setArtifactPlaceholderCommonFields(componentId, user, artifactInfo); - - return artifactInfo; - } - - public void setDefaultArtifactTimeout(ArtifactGroupTypeEnum groupType, ArtifactDataDefinition artifactInfo) { - if (groupType.equals(ArtifactGroupTypeEnum.DEPLOYMENT)) { - artifactInfo.setTimeout(defaultHeatTimeout); - } else { - artifactInfo.setTimeout(NON_HEAT_TIMEOUT); - } - } - - private void setArtifactPlaceholderCommonFields(String resourceId, User user, ArtifactDataDefinition artifactInfo) { - String uniqueId = null; - - if (resourceId != null) { - uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId.toLowerCase(), artifactInfo.getArtifactLabel().toLowerCase()); - artifactInfo.setUniqueId(uniqueId); - } - artifactInfo.setUserIdCreator(user.getUserId()); - String fullName = user.getFullName(); - artifactInfo.setUpdaterFullName(fullName); - - long time = System.currentTimeMillis(); - - artifactInfo.setCreatorFullName(fullName); - artifactInfo.setCreationDate(time); - - artifactInfo.setLastUpdateDate(time); - artifactInfo.setUserIdLastUpdater(user.getUserId()); - - artifactInfo.setMandatory(true); - } - - /** - * - * @param originNodeType - * @param componentInstance - * @param updatedContainerVertex - * @return - */ - private StorageOperationStatus addCalculatedCapReqFromNodeType(NodeType originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { - - Map capabilities = originNodeType.getCapabilities(); - MapListCapabilityDataDefinition allCalculatedCap = prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance); - StorageOperationStatus calculatedResult; - if (allCalculatedCap != null) { - calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap, componentInstance.getUniqueId()); - - if (calculatedResult != StorageOperationStatus.OK) { - return calculatedResult; - } - } - Map capabiltiesProperties = originNodeType.getCapabilitiesProperties(); - if (capabiltiesProperties != null) { - Map updateKeyMap = capabiltiesProperties.entrySet().stream().collect(Collectors.toMap(e -> createCapPropertyKey(e.getKey(), componentInstance.getUniqueId()), Entry::getValue)); - MapCapabilityProperty mapCapabilityProperty = new MapCapabilityProperty(updateKeyMap); - calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabilityProperty, componentInstance.getUniqueId()); - if (calculatedResult != StorageOperationStatus.OK) { - return calculatedResult; - } - } - - MapListCapabilityDataDefinition fullCalculatedCap = new MapListCapabilityDataDefinition(); - calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, fullCalculatedCap, componentInstance.getUniqueId()); - - if (calculatedResult != StorageOperationStatus.OK) { - return calculatedResult; - } - - Map requirements = originNodeType.getRequirements(); - - MapListRequirementDataDefinition allCalculatedReq = prepareCalculatedRequirementForNodeType(requirements, componentInstance); - - StorageOperationStatus status; - if (allCalculatedReq != null) { - status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq, componentInstance.getUniqueId()); - if (status != StorageOperationStatus.OK) { - return status; - } - } - MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition(); - addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, fullCalculatedReq, componentInstance.getUniqueId()); - return StorageOperationStatus.OK; - - } - - public static String createCapPropertyKey(String key, String instanceId) { - StringBuilder sb = new StringBuilder(instanceId); - sb.append(ModelConverter.CAP_PROP_DELIM).append(instanceId).append(ModelConverter.CAP_PROP_DELIM).append(key); - return sb.toString(); - } - - /** - * Prepares a map of capabilities lists Produces a deep copy of the received map of capabilities Sets values to the specific fields according to received component instance - * - * @param capabilities - * @param componentInstance - * @return - */ - public MapListCapabilityDataDefinition prepareCalculatedCapabiltyForNodeType(Map capabilities, ComponentInstanceDataDefinition componentInstance) { - if (capabilities != null) { - MapListCapabilityDataDefinition allCalculatedCap = new MapListCapabilityDataDefinition(); - - populateCapability(capabilities, componentInstance, allCalculatedCap); - return allCalculatedCap; - } - return null; - } - - /** - * Prepares a map of requirements lists Produces a deep copy of the received map of requirements Sets values to the specific fields according to received component instance - * - * @param requirements - * @param componentInstance - * @return - */ - public MapListRequirementDataDefinition prepareCalculatedRequirementForNodeType(Map requirements, ComponentInstanceDataDefinition componentInstance) { - if (requirements != null) { - MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition(); - - populateRequirement(requirements, componentInstance, allCalculatedReq); - return allCalculatedReq; - } - return null; - } - - public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstanceDataDefinition componentInstance, List groups, Map> groupInstancesArtifacts) { - - StorageOperationStatus result = null; - Map groupInstanceToCreate = new HashMap<>(); - if (groupInstancesArtifacts != null && CollectionUtils.isNotEmpty(groups)) { - for (Map.Entry> groupArtifacts : groupInstancesArtifacts.entrySet()) { - Optional groupOptional = groups.stream().filter(g -> g.getUniqueId().equals(groupArtifacts.getKey())).findFirst(); - if (groupOptional.isPresent()) { - GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition((GroupDataDefinition) groupOptional.get(), (ComponentInstanceDataDefinition) componentInstance, null); - groupInstance.setGroupInstanceArtifacts(groupArtifacts.getValue().stream().map(ArtifactDataDefinition::getUniqueId).collect(Collectors.toList())); - groupInstance.setGroupInstanceArtifactsUuid(groupArtifacts.getValue().stream().map(ArtifactDataDefinition::getArtifactUUID).collect(Collectors.toList())); - groupInstanceToCreate.put(groupInstance.getName(), groupInstance); - } - } - } - if (MapUtils.isNotEmpty(groupInstanceToCreate)) { - result = addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, new MapDataDefinition<>(groupInstanceToCreate), componentInstance.getUniqueId()); - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private ComponentInstanceDataDefinition buildComponentInstanceDataDefinition(ComponentInstance resourceInstance, String containerComponentId, String instanceNewName, boolean generateUid, ToscaElement originToscaElement) { - String ciOriginComponentUid = resourceInstance.getComponentUid(); - - if (!ValidationUtils.validateStringNotEmpty(resourceInstance.getCustomizationUUID())) { - resourceInstance.setCustomizationUUID(generateCustomizationUUID()); - } - ComponentInstanceDataDefinition dataDefinition = new ComponentInstanceDataDefinition(resourceInstance); - - Long creationDate = resourceInstance.getCreationTime(); - Long modificationTime; - if (creationDate == null) { - creationDate = System.currentTimeMillis(); - modificationTime = creationDate; - } else { - modificationTime = System.currentTimeMillis(); - } - dataDefinition.setComponentUid(ciOriginComponentUid); - dataDefinition.setCreationTime(creationDate); - dataDefinition.setModificationTime(modificationTime); - if (StringUtils.isNotEmpty(instanceNewName)) { - dataDefinition.setName(instanceNewName); - resourceInstance.setName(instanceNewName); - } - if (StringUtils.isNotEmpty(dataDefinition.getName())) - dataDefinition.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(dataDefinition.getName())); - dataDefinition.setIcon(resourceInstance.getIcon()); - if (generateUid) { - dataDefinition.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(containerComponentId, ciOriginComponentUid, dataDefinition.getNormalizedName())); - resourceInstance.setUniqueId(dataDefinition.getUniqueId()); - } - if (StringUtils.isEmpty(dataDefinition.getComponentVersion()) && originToscaElement != null) - dataDefinition.setComponentVersion((String) originToscaElement.getMetadataValue(JsonPresentationFields.VERSION)); - if (StringUtils.isEmpty(dataDefinition.getComponentName()) && originToscaElement != null) - dataDefinition.setComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.NAME)); - if (originToscaElement != null && dataDefinition.getToscaComponentName() == null) - dataDefinition.setToscaComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); - if (dataDefinition.getOriginType() == null && originToscaElement != null) { - ResourceTypeEnum resourceType = originToscaElement.getResourceType(); - OriginTypeEnum originType = OriginTypeEnum.findByValue(resourceType.name()); - dataDefinition.setOriginType(originType); - } - if (dataDefinition.getOriginType() == OriginTypeEnum.ServiceProxy) - dataDefinition.setIsProxy(true); - - return dataDefinition; - } - - private Boolean isUniqueInstanceName(TopologyTemplate container, String instanceName) { - Boolean isUniqueName = true; - try { - isUniqueName = !container.getComponentInstances().values().stream().filter(ci -> ci.getName() != null && ci.getName().equals(instanceName)).findAny().isPresent(); - - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during fetching component instance with name {} from component container {}. {} ", instanceName, container.getName(), e.getMessage()); - } - return isUniqueName; - } - - private String buildComponentInstanceName(String instanceSuffixNumber, String instanceName) { - return instanceName + " " + (instanceSuffixNumber == null ? 0 : instanceSuffixNumber); - } - - public Either associateResourceInstances(String componentId, RequirementCapabilityRelDef relation) { - List relations = new ArrayList<>(); - relations.add(relation); - Either, StorageOperationStatus> associateResourceInstances = associateResourceInstances(componentId, relations); - if (associateResourceInstances.isRight()) { - return Either.right(associateResourceInstances.right().value()); - } - return Either.left(associateResourceInstances.left().value().get(0)); - } - - @SuppressWarnings({ "unchecked" }) - public Either, StorageOperationStatus> associateResourceInstances(String componentId, List relations) { - - Either containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (containerVEither.isRight()) { - TitanOperationStatus error = containerVEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - GraphVertex containerV = containerVEither.left().value(); - Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (capResult.isRight()) { - return Either.right(capResult.right().value()); - - } - Map calculatedCapabilty = capResult.left().value().getRight(); - - Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (capResult.isRight()) { - return Either.right(capResult.right().value()); - - } - Map fullFilledCapabilty = capFullResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (reqResult.isRight()) { - return Either.right(reqResult.right().value()); - } - Map calculatedRequirement = reqResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (reqResult.isRight()) { - return Either.right(reqResult.right().value()); - } - Map fullfilledRequirement = reqFullResult.left().value().getRight(); - - Map jsonComposition = (Map) containerV.getJson(); - CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - - StorageOperationStatus status; - List relationsList = new ArrayList<>(); - for (RequirementCapabilityRelDef relation : relations) { - List relationshipsResult = new ArrayList<>(); - String fromNode = relation.getFromNode(); - String toNode = relation.getToNode(); - List relationships = relation.getRelationships(); - if (relationships == null || relationships.isEmpty()) { - BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement definition sent in order to set the relation between {} to {}", fromNode, toNode); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT)); - } - - for (CapabilityRequirementRelationship immutablePair : relationships) { - String requirement = immutablePair.getRelation().getRequirement(); - - Either, StorageOperationStatus> associateRes = connectInstancesInContainer(fromNode, toNode, immutablePair.getRelation(), relation.isOriginUI(), calculatedCapabilty, calculatedRequirement, - fullFilledCapabilty, fullfilledRequirement, compositionDataDefinition, containerV.getUniqueId()); - - if (associateRes.isRight()) { - status = associateRes.right().value(); - BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to associate resource instance {} to resource instance {}. status is {}", fromNode, toNode, status); - return Either.right(status); - } - - RelationshipInstDataDefinition relationshipInstData = (RelationshipInstDataDefinition) associateRes.left().value().get(JsonPresentationFields.RELATIONSHIP); - RelationshipImpl relationshipImplResult = new RelationshipImpl(); - relationshipImplResult.setType(relationshipInstData.getType()); - RelationshipInfo requirementAndRelationshipPair = new RelationshipInfo(requirement, relationshipImplResult); - requirementAndRelationshipPair.setCapability(immutablePair.getRelation().getCapability()); - requirementAndRelationshipPair.setRequirement(immutablePair.getRelation().getRequirement()); - requirementAndRelationshipPair.setCapabilityOwnerId(relationshipInstData.getCapabilityOwnerId()); - requirementAndRelationshipPair.setRequirementOwnerId(relationshipInstData.getRequirementOwnerId()); - requirementAndRelationshipPair.setCapabilityUid(immutablePair.getRelation().getCapabilityUid()); - requirementAndRelationshipPair.setRequirementUid(immutablePair.getRelation().getRequirementUid()); - requirementAndRelationshipPair.setId(relationshipInstData.getUniqueId()); - CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship(); - capReqRel.setRelation(requirementAndRelationshipPair); - capReqRel.setCapability((CapabilityDataDefinition) associateRes.left().value().get(JsonPresentationFields.CAPABILITY)); - capReqRel.setRequirement((RequirementDataDefinition) associateRes.left().value().get(JsonPresentationFields.REQUIREMENT)); - relationshipsResult.add(capReqRel); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "update customization UUID for from CI {} and to CI {}", relation.getFromNode(), relation.getToNode()); - status = updateCustomizationUUID(relation.getFromNode(), compositionDataDefinition); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - status = updateCustomizationUUID(relation.getToNode(), compositionDataDefinition); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - RequirementCapabilityRelDef reqCapRelDef = new RequirementCapabilityRelDef(relation); - reqCapRelDef.setRelationships(relationshipsResult); - relationsList.add(reqCapRelDef); - } - // update metadata of container and composition json - status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - - return Either.left(relationsList); - } - - private StorageOperationStatus updateAllAndCalculatedCapReqOnGraph(String componentId, GraphVertex containerV, Either>, StorageOperationStatus> capResult, - Either>, StorageOperationStatus> capFullResult, Either>, StorageOperationStatus> reqResult, - Either>, StorageOperationStatus> reqFullResult) { - containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - Either updateElement = titanDao.updateVertex(containerV); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new relations error {}. ", componentId, updateElement.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()); - } - // update cap/req jsons, fulfilled cap/req jsons!!!!! - Either status; - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated capabilty for container {}", containerV.getUniqueId()); - status = updateOrCopyOnUpdate(capResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (status.isRight()) { - TitanOperationStatus error = status.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated capabilty for container {} error {}", containerV.getUniqueId(), error); - return DaoStatusConverter.convertTitanStatusToStorageStatus(error); - } - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated requirement for container {}", containerV.getUniqueId()); - status = updateOrCopyOnUpdate(reqResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (status.isRight()) { - TitanOperationStatus error = status.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated requiremnt for container {} error {}", containerV.getUniqueId(), error); - return DaoStatusConverter.convertTitanStatusToStorageStatus(error); - } - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled capabilty for container {}", containerV.getUniqueId()); - status = updateOrCopyOnUpdate(capFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (status.isRight()) { - TitanOperationStatus error = status.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled capabilty for container {} error {}", containerV.getUniqueId(), error); - return DaoStatusConverter.convertTitanStatusToStorageStatus(error); - } - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled requirement for container {}", containerV.getUniqueId()); - status = updateOrCopyOnUpdate(reqFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (status.isRight()) { - TitanOperationStatus error = status.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled requirement for container {} error {}", containerV.getUniqueId(), error); - return DaoStatusConverter.convertTitanStatusToStorageStatus(error); - } - return StorageOperationStatus.OK; - } - - @SuppressWarnings({ "unchecked" }) - public Either dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { - if (requirementDef.getRelationships() == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No relation pair in request [ {} ]", requirementDef); - return Either.right(StorageOperationStatus.BAD_REQUEST); - } - - String fromResInstanceUid = requirementDef.getFromNode(); - String toResInstanceUid = requirementDef.getToNode(); - - Either containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (containerVEither.isRight()) { - TitanOperationStatus error = containerVEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - GraphVertex containerV = containerVEither.left().value(); - - // DE191707 - validations - Map jsonComposition = (Map) containerV.getJson(); - CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - Map componentInstances = compositionDataDefinition.getComponentInstances(); - ComponentInstanceDataDefinition ciFrom = componentInstances.get(fromResInstanceUid); - if (ciFrom == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "FROM instance {} isn't under container {}", fromResInstanceUid, componentId); - return Either.right(StorageOperationStatus.NOT_FOUND); - - } - ComponentInstanceDataDefinition ciTo = componentInstances.get(toResInstanceUid); - if (ciFrom == ciTo) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "TO instance {} isn't under container {}", toResInstanceUid, componentId); - return Either.right(StorageOperationStatus.NOT_FOUND); - - } - Map relations = compositionDataDefinition.getRelations(); - - List relationPairList = requirementDef.getRelationships(); - Either>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (capResult.isRight()) { - return Either.right(capResult.right().value()); - } - Map calculatedCapability = capResult.left().value().getRight(); - - Either>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (capResult.isRight()) { - return Either.right(capResult.right().value()); - - } - Map fulfilledCapability = capFullResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (reqResult.isRight()) { - return Either.right(reqResult.right().value()); - } - Map calculatedRequirement = reqResult.left().value().getRight(); - - Either>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (reqResult.isRight()) { - return Either.right(reqResult.right().value()); - } - Map fulfilledRequirement = reqFullResult.left().value().getRight(); - - for (CapabilityRequirementRelationship relationPair : relationPairList) { - Iterator> iterator = relations.entrySet().iterator(); - boolean isDeleted = false; - while (iterator.hasNext()) { - Entry entryInJson = iterator.next(); - RelationshipInstDataDefinition relationInJson = entryInJson.getValue(); - if (relationInJson.getFromId().equals(fromResInstanceUid) && relationInJson.getToId().equals(toResInstanceUid) && relationInJson.getUniqueId().equals(relationPair.getRelation().getId())) { - if (relationPair.getRelation().equalsTo(relationInJson)) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Remove relation from {} to {} capability {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationInJson.getType(), relationInJson.getCapabilityOwnerId(), - relationInJson.getRequirementOwnerId()); - iterator.remove(); - - // update calculated cap/req - StorageOperationStatus status = updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapability, fulfilledCapability, toResInstanceUid, relationInJson, relationPair); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - status = updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fulfilledRequirement, fromResInstanceUid, relationInJson, relationPair); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - isDeleted = true; - } - } - } - if (!isDeleted) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No relation to delete from {} to {} capabilty {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationPair.getCapability(), - relationPair.getRelation().getCapabilityOwnerId(), relationPair.getRelation().getRequirementOwnerId()); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - } - StorageOperationStatus status = updateCustomizationUUID(fromResInstanceUid, compositionDataDefinition); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - status = updateCustomizationUUID(toResInstanceUid, compositionDataDefinition); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - - // update jsons - // update metadata of container and composition json - status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - - return Either.left(requirementDef); - } - - /** - * Retrieves fulfilled requirement according to relation and received predicate - * - * @param componentId - * @param instanceId - * @param foundRelation - * @param predicate - * @return - */ - public Either getFulfilledRequirementByRelation(String componentId, String instanceId, RequirementCapabilityRelDef foundRelation, - BiPredicate predicate) { - - Either result = null; - Either>, StorageOperationStatus> reqFullResult = null; - MapListRequirementDataDefinition reqMapOfLists = null; - Optional foundRequirement; - RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation(); - Either containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (containerVEither.isRight()) { - TitanOperationStatus error = containerVEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - if (result == null) { - GraphVertex containerV = containerVEither.left().value(); - reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (reqFullResult.isRight()) { - result = Either.right(reqFullResult.right().value()); - } - } - if (result == null) { - Map fulfilledRequirement = reqFullResult.left().value().getRight(); - reqMapOfLists = fulfilledRequirement.get(instanceId); - if (reqMapOfLists == null) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - if (result == null && reqMapOfLists != null) { - for (ListRequirementDataDefinition requirements : reqMapOfLists.getMapToscaDataDefinition().values()) { - foundRequirement = requirements.getListToscaDataDefinition().stream().filter(req -> predicate.test(relationshipInfo, req)).findFirst(); - if (foundRequirement.isPresent()) { - result = Either.left(foundRequirement.get()); - } - } - } - return result; - } - - /** - * Retrieves fulfilled capability according to relation and received predicate - * - * @param componentId - * @param instanceId - * @param foundRelation - * @param predicate - * @return - */ - public Either getFulfilledCapabilityByRelation(String componentId, String instanceId, RequirementCapabilityRelDef foundRelation, - BiPredicate predicate) { - - Either result = null; - Either>, StorageOperationStatus> capFullResult = null; - MapListCapabilityDataDefinition capMapOfLists = null; - Optional foundRequirement; - - RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation(); - Either containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (containerVEither.isRight()) { - TitanOperationStatus error = containerVEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - if (result == null) { - GraphVertex containerV = containerVEither.left().value(); - capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (capFullResult.isRight()) { - result = Either.right(capFullResult.right().value()); - } - } - if (result == null) { - Map fulfilledCapability = capFullResult.left().value().getRight(); - capMapOfLists = fulfilledCapability.get(instanceId); - if (capMapOfLists == null) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - if (result == null && capMapOfLists != null) { - for (ListCapabilityDataDefinition capabilities : capMapOfLists.getMapToscaDataDefinition().values()) { - foundRequirement = capabilities.getListToscaDataDefinition().stream().filter(cap -> predicate.test(relationshipInfo, cap)).findFirst(); - if (foundRequirement.isPresent()) { - result = Either.left(foundRequirement.get()); - } - } - } - return result; - } - - private StorageOperationStatus updateCalculatedRequirementsAfterDeleteRelation(Map calculatedRequirement, Map fullFilledRequirement, String fromResInstanceUid, - RelationshipInstDataDefinition relation, CapabilityRequirementRelationship relationship) { - StorageOperationStatus status; - String hereIsTheKey = null; - MapListRequirementDataDefinition reqByInstance = calculatedRequirement.get(fromResInstanceUid); - if (reqByInstance == null || reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()) == null) { - // move from fulfilled - status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation, hereIsTheKey, relationship); - } else { - hereIsTheKey = reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()); - ListRequirementDataDefinition reqByType = reqByInstance.findByKey(hereIsTheKey); - Optional requirementOptional = reqByType.getListToscaDataDefinition().stream() - .filter(req -> req.getOwnerId().equals(relation.getRequirementOwnerId()) && req.getName().equals(relation.getRequirement()) && req.getUniqueId().equals(relation.getRequirementId())).findFirst(); - - if (requirementOptional.isPresent()) { - - RequirementDataDefinition requirement = requirementOptional.get(); - String leftOccurrences = requirement.getLeftOccurrences(); - if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) { - Integer leftIntValue = Integer.parseInt(leftOccurrences); - ++leftIntValue; - requirement.setLeftOccurrences(String.valueOf(leftIntValue)); - } - if (relationship != null) { - relationship.setRequirement(requirement); - } - status = StorageOperationStatus.OK; - } else { - // move from fulfilled - status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation, hereIsTheKey, relationship); - } - } - return status; - } - - private StorageOperationStatus updateCalculatedCapabiltyAfterDeleteRelation(Map calculatedCapability, Map fullFilledCapability, String toResInstanceUid, - RelationshipInstDataDefinition relation, CapabilityRequirementRelationship relationship) { - StorageOperationStatus status; - String hereIsTheKey = null; - MapListCapabilityDataDefinition capByInstance = calculatedCapability.get(toResInstanceUid); - if (capByInstance == null || capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()) == null) { - // move from fulfilled - status = moveFromFullFilledCapabilty(calculatedCapability, fullFilledCapability, toResInstanceUid, relation, hereIsTheKey, relationship); - } else { - hereIsTheKey = capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()); - ListCapabilityDataDefinition capByType = capByInstance.findByKey(hereIsTheKey); - Optional capabilityOptional = capByType.getListToscaDataDefinition().stream().filter(cap -> cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getUniqueId().equals(relation.getCapabilityId())) - .findFirst(); - - if (capabilityOptional.isPresent()) { - - CapabilityDataDefinition capability = capabilityOptional.get(); - String leftOccurrences = capability.getLeftOccurrences(); - if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { - Integer leftIntValue = Integer.parseInt(leftOccurrences); - ++leftIntValue; - capability.setLeftOccurrences(String.valueOf(leftIntValue)); - } - if (relationship != null) { - relationship.setCapability(capability); - } - status = StorageOperationStatus.OK; - } else { - // move from fulfilled - status = moveFromFullFilledCapabilty(calculatedCapability, fullFilledCapability, toResInstanceUid, relation, hereIsTheKey, relationship); - } - } - return status; - } - - private StorageOperationStatus moveFromFullFilledCapabilty(Map calculatedCapability, Map fullFilledCapability, String toResInstanceUid, - RelationshipInstDataDefinition relation, String hereIsTheKey, CapabilityRequirementRelationship relationship) { - MapListCapabilityDataDefinition capByInstance = fullFilledCapability.get(toResInstanceUid); - if (capByInstance == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability in fulfilled list for instance {} ", toResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - if (null == hereIsTheKey) - hereIsTheKey = capByInstance.findKeyByItemUidMatch(relation.getCapabilityId()); - if (null == hereIsTheKey) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability with id {} in fulfilled list for instance {} ", relation.getCapabilityId(), toResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - ListCapabilityDataDefinition capByType = capByInstance.findByKey(hereIsTheKey); - Iterator iterator = capByType.getListToscaDataDefinition().iterator(); - boolean found = false; - while (iterator.hasNext()) { - CapabilityDataDefinition cap = iterator.next(); - if (cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getUniqueId().equals(relation.getCapabilityId())) { - found = true; - iterator.remove(); - // return to calculated list - String leftOccurrences = cap.getLeftOccurrences(); - Integer leftIntValue = Integer.parseInt(leftOccurrences); - ++leftIntValue; - cap.setLeftOccurrences(String.valueOf(leftIntValue)); - - MapListCapabilityDataDefinition mapListCapaDataDef = calculatedCapability.get(toResInstanceUid); - if (mapListCapaDataDef == null) { - mapListCapaDataDef = new MapListCapabilityDataDefinition(); - } - ListCapabilityDataDefinition findByKey = mapListCapaDataDef.findByKey(hereIsTheKey); - if (findByKey == null) { - findByKey = new ListCapabilityDataDefinition(); - mapListCapaDataDef.put(hereIsTheKey, findByKey); - } - findByKey.add(cap); - if (relationship != null) - relationship.setCapability(cap); - break; - } - } - if (!found) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No capability type {} with ownerId {} in fulfilled list for instance {} ", hereIsTheKey, relation.getCapabilityOwnerId(), toResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus moveFromFullFilledRequirement(Map calculatedRequirement, Map fullFilledRequirement, String fromResInstanceUid, - RelationshipInstDataDefinition relation, String hereIsTheKey, CapabilityRequirementRelationship relationship) { - MapListRequirementDataDefinition reqByInstance = fullFilledRequirement.get(fromResInstanceUid); - if (reqByInstance == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement in fullfilled list for instance {} ", fromResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - if (null == hereIsTheKey) - hereIsTheKey = reqByInstance.findKeyByItemUidMatch(relation.getRequirementId()); - if (null == hereIsTheKey) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement with id {} in fulfilled list for instance {} ", relation.getRequirementId(), fromResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - ListRequirementDataDefinition reqByType = reqByInstance.findByKey(hereIsTheKey); - Iterator iterator = reqByType.getListToscaDataDefinition().iterator(); - boolean found = false; - while (iterator.hasNext()) { - RequirementDataDefinition req = iterator.next(); - if (req.getOwnerId().equals(relation.getRequirementOwnerId()) && req.getName().equals(relation.getRequirement()) && req.getUniqueId().equals(relation.getRequirementId())) { - found = true; - iterator.remove(); - // return to calculated list - String leftOccurrences = req.getLeftOccurrences(); - Integer leftIntValue = Integer.parseInt(leftOccurrences); - ++leftIntValue; - req.setLeftOccurrences(String.valueOf(leftIntValue)); - - MapListRequirementDataDefinition mapListReqDataDef = calculatedRequirement.get(fromResInstanceUid); - if (mapListReqDataDef == null) { - mapListReqDataDef = new MapListRequirementDataDefinition(); - } - ListRequirementDataDefinition findByKey = mapListReqDataDef.findByKey(hereIsTheKey); - if (findByKey == null) { - findByKey = new ListRequirementDataDefinition(); - mapListReqDataDef.put(hereIsTheKey, findByKey); - } - findByKey.add(req); - if (relationship != null) - relationship.setRequirement(req); - break; - } - } - if (!found) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement type {} with ownerId {} in fulfilled list for instance {} ", hereIsTheKey, relation.getRequirementOwnerId(), fromResInstanceUid); - return StorageOperationStatus.GENERAL_ERROR; - } - return StorageOperationStatus.OK; - - } - - public StorageOperationStatus updateCustomizationUUID(String componentInstanceId, CompositionDataDefinition compositionDataDefinition) { - ComponentInstanceDataDefinition componentInstance = compositionDataDefinition.getComponentInstances().get(componentInstanceId); - - if (componentInstance == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch component instance by id {} from map of instances ", componentInstanceId); - return StorageOperationStatus.NOT_FOUND; - } - UUID uuid = UUID.randomUUID(); - componentInstance.setCustomizationUUID(uuid.toString()); - - return StorageOperationStatus.OK; - } - - public Either, StorageOperationStatus> connectInstancesInContainer(String fromResInstanceUid, String toResInstanceUid, RelationshipInfo relationPair, boolean originUI, - Map calculatedCapabilty, Map calculatedRequirement, Map fullfilledCapabilty, - Map fullfilledRequirement, CompositionDataDefinition compositionDataDefinition, String containerId) { - String requirement = relationPair.getRequirement(); - Map componentInstances = compositionDataDefinition.getComponentInstances(); - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to associate resource instance {} to resource instance {} under component {}. Requirement is {}.", fromResInstanceUid, toResInstanceUid, containerId, requirement); - - ComponentInstanceDataDefinition fromResourceInstData = componentInstances.get(fromResInstanceUid); - if (fromResourceInstData == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find from resource instance {}.", fromResInstanceUid); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - ComponentInstanceDataDefinition toResourceInstData = componentInstances.get(toResInstanceUid); - if (toResourceInstData == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find to resource instance {}.", toResInstanceUid); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - - Either, StorageOperationStatus> reqVsCap = connectRequirementVsCapability(fromResourceInstData, toResourceInstData, relationPair, originUI, calculatedCapabilty, calculatedRequirement, fullfilledCapabilty, - fullfilledRequirement, containerId); - if (reqVsCap.isRight()) { - StorageOperationStatus status = reqVsCap.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to connect requirement {} between resource instance {} to resource instance {}. status is {}", requirement, fromResInstanceUid, toResInstanceUid, status); - return Either.right(status); - } - Map relationship = reqVsCap.left().value(); - - // add to json new relations - compositionDataDefinition.addRelation(((RelationshipInstDataDefinition) relationship.get(JsonPresentationFields.RELATIONSHIP)).getUniqueId(), (RelationshipInstDataDefinition) relationship.get(JsonPresentationFields.RELATIONSHIP)); - - return Either.left(relationship); - } - - private Either>, StorageOperationStatus> fetchContainerCalculatedCapability(GraphVertex containerV, EdgeLabelEnum capLabel) { - - Either>, TitanOperationStatus> calculatedCapabiltyEither = getDataAndVertexFromGraph(containerV, capLabel); - if (calculatedCapabiltyEither.isRight()) { - TitanOperationStatus error = calculatedCapabiltyEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilties for container {}.", containerV.getUniqueId(), error); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - Pair> calculatedCapabilty = calculatedCapabiltyEither.left().value(); - return Either.left(calculatedCapabilty); - } - - private Either>, StorageOperationStatus> fetchContainerCalculatedRequirement(GraphVertex containerV, EdgeLabelEnum reqLabel) { - Either>, TitanOperationStatus> calculatedRequirementEither = getDataAndVertexFromGraph(containerV, reqLabel); - if (calculatedRequirementEither.isRight()) { - TitanOperationStatus error = calculatedRequirementEither.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for container {}.", containerV.getUniqueId(), error); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - Pair> calculatedRequirement = calculatedRequirementEither.left().value(); - return Either.left(calculatedRequirement); - } - - @SuppressWarnings("unchecked") - private Either, StorageOperationStatus> connectRequirementVsCapability(ComponentInstanceDataDefinition fromResInstance, ComponentInstanceDataDefinition toResInstance, - RelationshipInfo relationPair, boolean originUI, Map calculatedCapabilty, Map calculatedRequirement, - Map fullfilledCapabilty, Map fullfilledRequirement, String containerId) { - String type = relationPair.getRelationship().getType(); - // capability - - String toInstId = toResInstance.getUniqueId(); - MapListCapabilityDataDefinition mapListCapabilityDataDefinition = calculatedCapabilty.get(toInstId); - Map capReqRelationship = new EnumMap<>(JsonPresentationFields.class); - - if (mapListCapabilityDataDefinition == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for instance {} in container {}.", toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - ListCapabilityDataDefinition listCapabilityDataDefinition = mapListCapabilityDataDefinition.getMapToscaDataDefinition().get(type); - if (listCapabilityDataDefinition == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for type {} for instance {} in container {}.", type, toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - CapabilityDataDefinition capabilityForRelation = null; - Iterator iteratorCap = listCapabilityDataDefinition.getListToscaDataDefinition().iterator(); - while (iteratorCap.hasNext()) { - CapabilityDataDefinition cap = iteratorCap.next(); - if (cap.getUniqueId().equals(relationPair.getCapabilityUid()) && cap.getOwnerId().equals(relationPair.getCapabilityOwnerId())) { - capabilityForRelation = cap; - capReqRelationship.put(JsonPresentationFields.CAPABILITY, (T) capabilityForRelation); - String leftOccurrences = cap.getLeftOccurrences(); - if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) { - Integer leftIntValue = Integer.parseInt(leftOccurrences); - if (leftIntValue > 0) { - --leftIntValue; - capabilityForRelation.setLeftOccurrences(String.valueOf(leftIntValue)); - if (leftIntValue == 0) { - // remove from calculated - iteratorCap.remove(); - // move to fulfilled - MapListCapabilityDataDefinition mapListCapabiltyFullFilledInst = fullfilledCapabilty.get(toInstId); - if (mapListCapabiltyFullFilledInst == null) { - mapListCapabiltyFullFilledInst = new MapListCapabilityDataDefinition(); - fullfilledCapabilty.put(toInstId, mapListCapabiltyFullFilledInst); - } - - ListCapabilityDataDefinition listCapabilityFull = mapListCapabiltyFullFilledInst.findByKey(type); - if (listCapabilityFull == null) { - listCapabilityFull = new ListCapabilityDataDefinition(); - mapListCapabiltyFullFilledInst.put(type, listCapabilityFull); - } - listCapabilityFull.add(capabilityForRelation); - } - break; - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No left occurrences capabilty {} to {} in container {}.", capabilityForRelation.getType(), toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - } - } - } - if (capabilityForRelation == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch capabilty for type {} for instance {} in container {}.", type, toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - - // requirements - String fromInstId = fromResInstance.getUniqueId(); - MapListRequirementDataDefinition mapListRequirementDataDefinition = calculatedRequirement.get(fromInstId); - if (mapListRequirementDataDefinition == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for instance {} in container {}.", fromInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - ListRequirementDataDefinition listRequirementDataDefinition = mapListRequirementDataDefinition.getMapToscaDataDefinition().get(type); - if (listRequirementDataDefinition == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for type {} for instance {} in container {}.", type, fromInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - - RequirementDataDefinition requirementForRelation = null; - Iterator iteratorReq = listRequirementDataDefinition.getListToscaDataDefinition().iterator(); - while (iteratorReq.hasNext()) { - RequirementDataDefinition req = iteratorReq.next(); - if (req.getUniqueId().equals(relationPair.getRequirementUid()) && req.getOwnerId().equals(relationPair.getRequirementOwnerId())) { - requirementForRelation = req; - capReqRelationship.put(JsonPresentationFields.REQUIREMENT, (T) requirementForRelation); - String leftOccurrences = req.getLeftOccurrences(); - if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) { - Integer leftIntValue = Integer.parseInt(leftOccurrences); - if (leftIntValue > 0) { - --leftIntValue; - req.setLeftOccurrences(String.valueOf(leftIntValue)); - if (leftIntValue == 0) { - // remove from calculated - iteratorReq.remove(); - // move to fulfilled - MapListRequirementDataDefinition mapListRequirementFullFilledInst = fullfilledRequirement.get(fromInstId); - if (mapListRequirementFullFilledInst == null) { - mapListRequirementFullFilledInst = new MapListRequirementDataDefinition(); - fullfilledRequirement.put(fromInstId, mapListRequirementFullFilledInst); - } - - ListRequirementDataDefinition listRequirementFull = mapListRequirementFullFilledInst.findByKey(type); - if (listRequirementFull == null) { - listRequirementFull = new ListRequirementDataDefinition(); - mapListRequirementFullFilledInst.put(type, listRequirementFull); - } - listRequirementFull.add(requirementForRelation); - } - break; - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No left occurrences requirement {} from {} to {} in container {}.", requirementForRelation.getCapability(), fromInstId, toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - } - } - } - if (requirementForRelation == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch requirement for type {} for instance {} in container {}.", type, toInstId, containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - if (!capabilityForRelation.getType().equals(requirementForRelation.getCapability())) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No macth for capability from type {} and requirement {} from {} to {} in container {}.", capabilityForRelation.getType(), requirementForRelation.getCapability(), fromInstId, toInstId, - containerId); - return Either.right(StorageOperationStatus.MATCH_NOT_FOUND); - } - - RelationshipInstDataDefinition relationshipTypeData = buildRelationshipInstData(fromInstId, toInstId, relationPair, originUI); - if (requirementForRelation.getRelationship() != null) - relationshipTypeData.setType(requirementForRelation.getRelationship()); - capReqRelationship.put(JsonPresentationFields.RELATIONSHIP, (T) relationshipTypeData); - return Either.left(capReqRelationship); - } - - private RelationshipInstDataDefinition buildRelationshipInstData(String fromResInstanceUid, String toInstId, RelationshipInfo relationPair, boolean originUI) { - - RelationshipInstDataDefinition relationshipInstData = new RelationshipInstDataDefinition(); - relationshipInstData.setUniqueId(UniqueIdBuilder.buildRelationsipInstInstanceUid(fromResInstanceUid, toInstId)); - - relationshipInstData.setType(relationPair.getRelationship().getType()); - Long creationDate = System.currentTimeMillis(); - relationshipInstData.setCreationTime(creationDate); - relationshipInstData.setModificationTime(creationDate); - relationshipInstData.setCapabilityOwnerId(relationPair.getCapabilityOwnerId()); - relationshipInstData.setRequirementOwnerId(relationPair.getRequirementOwnerId()); - relationshipInstData.setCapabilityId(relationPair.getCapabilityUid()); - relationshipInstData.setRequirementId(relationPair.getRequirementUid()); - relationshipInstData.setFromId(fromResInstanceUid); - relationshipInstData.setToId(toInstId); - relationshipInstData.setRequirement(relationPair.getRequirement()); - relationshipInstData.setCapability(relationPair.getCapability()); - relationshipInstData.setOriginUI(originUI); - - return relationshipInstData; - } - - public StorageOperationStatus associateComponentInstancesToComponent(Component containerComponent, Map componentInstanceTMap, GraphVertex containerVertex, boolean allowDeleted) { - - StorageOperationStatus result = null; - String containerId = containerComponent.getUniqueId(); - Map instancesJsonData = null; - Either updateElement = null; - if (!validateInstanceNames(componentInstanceTMap)) { - result = StorageOperationStatus.INCONSISTENCY; - } - if (result == null && !validateInstanceNames(componentInstanceTMap)) { - result = StorageOperationStatus.INCONSISTENCY; - } - if (result == null && !allowDeleted && !validateDeletedResources(componentInstanceTMap)) { - result = StorageOperationStatus.INCONSISTENCY; - } - if (result == null) { - instancesJsonData = convertToComponentInstanceDataDefinition(componentInstanceTMap, containerId); - } - if (result == null && MapUtils.isNotEmpty(instancesJsonData)) { - containerVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - Map compositions = new HashMap<>(); - CompositionDataDefinition composition = new CompositionDataDefinition(); - composition.setComponentInstances(instancesJsonData); - compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition); - containerVertex.setJson(compositions); - updateElement = titanDao.updateVertex(containerVertex); - if (updateElement.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instances. ", containerComponent.getName()); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()); - } - } - if (result == null && updateElement != null) { - GraphVertex vertexC = updateElement.left().value(); - instancesJsonData.entrySet().forEach(i ->createInstanceEdge(vertexC, i.getValue())); - result = StorageOperationStatus.OK; - } - return result; - } - - private Map convertToComponentInstanceDataDefinition(Map componentInstanceTMap, String containerId) { - - Map instances = new HashMap<>(); - for (Entry entry : componentInstanceTMap.entrySet()) { - ComponentInstanceDataDefinition instance = buildComponentInstanceDataDefinition(entry.getKey(), containerId, null, true, ModelConverter.convertToToscaElement(entry.getValue())); - instances.put(instance.getUniqueId(), instance); - } - return instances; - } - - private boolean validateDeletedResources(Map resourcesInstancesMap) { - boolean result = true; - for (Component component : resourcesInstancesMap.values()) { - if (component.getIsDeleted() != null && component.getIsDeleted()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance. ", component.getName()); - result = false; - break; - } - } - return result; - } - - private boolean validateInstanceNames(Map resourcesInstancesMap) { - boolean result = true; - Set names = new HashSet<>(); - for (ComponentInstance instance : resourcesInstancesMap.keySet()) { - if (StringUtils.isEmpty(instance.getName())) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component instance {} name is empty. Cannot add component instance. ", instance.getUniqueId()); - result = false; - break; - } else if (names.contains(instance.getName())) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Component instance with the name {} already exsists. Cannot add component instance. ", instance.getName()); - result = false; - break; - } else { - names.add(instance.getName()); - } - } - return result; - } - - public StorageOperationStatus addDeploymentArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts) { - return addArtifactsToInstance(toscaElementId, instanceId, instDeplArtifacts, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS); - } - - public StorageOperationStatus addInformationalArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts) { - return addArtifactsToInstance(toscaElementId, instanceId, instDeplArtifacts, EdgeLabelEnum.INSTANCE_ARTIFACTS, VertexTypeEnum.INSTANCE_ARTIFACTS); - } - - public StorageOperationStatus addArtifactsToInstance(String toscaElementId, String instanceId, Map instDeplArtifacts, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexType) { - Either metadataVertex = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - MapArtifactDataDefinition instArtifacts = new MapArtifactDataDefinition(instDeplArtifacts); - return addToscaDataDeepElementsBlockToToscaElement(metadataVertex.left().value(), edgeLabel, vertexType, instArtifacts, instanceId); - - } - - @SuppressWarnings({ "unchecked" }) - public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) { - Either metadataVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - GraphVertex metaVertex = metadataVertex.left().value(); - Map json = (Map) metaVertex.getJson(); - CompositionDataDefinition compositionDataDefinition = json.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - StorageOperationStatus status = updateCustomizationUUID(instanceId, compositionDataDefinition); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update customization UUID for instance {} in component {} error {}", instanceId, componentId, status); - return status; - } - Either updateVertex = titanDao.updateVertex(metaVertex); - if (updateVertex.isRight()) { - log.debug("Failed to update vertex of component {} error {}", componentId, updateVertex.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertex.right().value()); - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List groupInstances) { - if (groupInstances != null) { - Either, TitanOperationStatus> dataFromGraph = getDataFromGraph(componentId, EdgeLabelEnum.INST_GROUPS); - if (dataFromGraph.isRight()) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(dataFromGraph.right().value()); - } - MapGroupsDataDefinition grInstPerInstance = dataFromGraph.left().value().get(instanceId); - if (grInstPerInstance == null) { - log.debug("No instance groups for instance {} in component {}", instanceId, componentId); - return StorageOperationStatus.NOT_FOUND; - } - for (String instGroupForUpdate : groupInstances) { - GroupInstanceDataDefinition groupInst = grInstPerInstance.findByKey(instGroupForUpdate); - if (groupInst == null) { - log.debug("No group instance {} in group list for instance {} in component {}", instGroupForUpdate, instanceId, componentId); - continue; - } - UUID uuid = UUID.randomUUID(); - groupInst.setCustomizationUUID(uuid.toString()); - } - - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groupInstances) { - - return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, - new MapDataDefinition<>(groupInstances.stream().collect(Collectors.toMap(GroupInstanceDataDefinition::getName, gi -> gi))), componentInstance.getUniqueId()); - } - - public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map deploymentArtifacts) { - - return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, new MapDataDefinition<>(deploymentArtifacts), - componentInstance.getUniqueId()); - } - - public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { - - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus updateComponentInstanceCapabilityProperty(Component containerComponent, String componentInstanceId, String capabilityUniqueId, ComponentInstanceProperty property) { - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - pathKeys.add(capabilityUniqueId); - return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus overrideComponentCapabilitiesProperties(Component containerComponent, Map capabilityPropertyMap) { - return overrideToscaDataOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilityPropertyMap); - } - - public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus updateComponentInstanceProperties(Component containerComponent, String componentInstanceId, List properties) { - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return updateToscaDataDeepElementsOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, properties, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus updateComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus addComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { - - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus updateComponentInstanceInputs(Component containerComponent, String componentInstanceId, List properties) { - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return updateToscaDataDeepElementsOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, properties, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { - List pathKeys = new ArrayList<>(); - pathKeys.add(componentInstanceId); - return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME); - } - - public StorageOperationStatus createInstanceEdge(GraphVertex metadataVertex, ComponentInstanceDataDefinition componentInstance) { - String instUniqueId = componentInstance.getUniqueId(); - - // create edge between container and origin ( in case of proxy this edge will be to ProxyService node type) - StorageOperationStatus result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId).either(v -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); - - if (result == StorageOperationStatus.OK && componentInstance.getIsProxy()) { - // create edge between container and service origin - result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId) - .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertTitanStatusToStorageStatus); - } - return result; - } - - public StorageOperationStatus createAllottedOfEdge(String componentId, String instanceId, String serviceUUID) { - Either vertexById = titanDao.getVertexById(componentId); - if ( vertexById.isRight() ){ - log.debug("Failed to fetch component metadata vertex for id {} error {}", componentId, vertexById.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(vertexById.right().value()); - } - GraphVertex metadataVertex = vertexById.left().value(); - - EnumMap props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.UUID, serviceUUID); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - EnumMap hasNot = new EnumMap<>(GraphPropertyEnum.class); - hasNot.put(GraphPropertyEnum.IS_DELETED, true); - - Either, TitanOperationStatus> byCriteria = titanDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props,hasNot, JsonParseFlagEnum.ParseMetadata ); - if ( byCriteria.isRight() ){ - log.debug("Failed to fetch vertex by criteria {} error {}", props, byCriteria.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()); - } - List vertecies = byCriteria.left().value(); - StorageOperationStatus result = StorageOperationStatus.OK; - if ( vertecies != null ){ - GraphVertex serviceVertex = vertecies.get(0); - //remove previous edges - - log.debug("Try to create or update edge between resource {} and service {} ", metadataVertex, serviceVertex.getUniqueId()); - // create edge between container and service reference - result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.ALLOTTED_OF, serviceVertex.getUniqueId(), instanceId).either(v -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - return result; - } - - - public StorageOperationStatus removeInstanceEdge(GraphVertex metadataVertex, ComponentInstanceDataDefinition componentInstance) { - String instUniqueId = componentInstance.getUniqueId(); - - // create edge between container and origin ( in case of proxy this edge will be to ProxyService node type) - StorageOperationStatus result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId) - .either(v -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); - - if (componentInstance.getIsProxy()) { - // create edge between container and service origin - result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId) - .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertTitanStatusToStorageStatus); - } - return result; - } - - private Either createOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) { - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid); - - return titanDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties) - .left() - .bind(v -> addInstanceToPropertyOnEdge(instUniqueId, v, metadataVertex)) - .right() - .bind(s -> createInstanceEdge(metadataVertex, edgeLabel, componentUid, instUniqueId, s)); - } - - private Either removeOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) { - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid); - - return titanDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties).left().bind(v -> removeInstanceFromPropertyOnEdge(instUniqueId, v, metadataVertex)).right() - .map(err -> removeInstanceEdgeLogError(metadataVertex, edgeLabel, componentUid, err)); - } - - private Either addInstanceToPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) { - // edge exist need to add instance id to list on edge's property - List property = (List) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES); - if (property == null) { - property = new ArrayList<>(); - } - Optional findFirst = property.stream().filter(a -> a.equals(instUniqueId)).findFirst(); - if (!findFirst.isPresent()) { - property.add(instUniqueId); - } - try { - String jsonArr = JsonParserUtils.toJson(property); - log.debug("Update INSTANCES edge property with value {} ", jsonArr ); - - edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr); - } catch (IOException e) { - log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e ); - return Either.right(TitanOperationStatus.GENERAL_ERROR); - } - return Either.left(metadataVertex); - } - - private Either removeInstanceFromPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) { - // edge exist need to add instance id to list on edge's property - List property = (List) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES); - if (property == null) { - property = new ArrayList<>(); - } - Optional findFirst = property.stream().filter(a -> a.equals(instUniqueId)).findFirst(); - if (findFirst.isPresent()) { - property.remove(instUniqueId); - } - if (property.isEmpty()) { - // For last instance need to remove edge - edge.remove(); - } else { - try { - String jsonArr = JsonParserUtils.toJson(property); - edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr); - } catch (IOException e) { - log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e ); - return Either.right(TitanOperationStatus.GENERAL_ERROR); - } - } - return Either.left(metadataVertex); - } - - private Either createInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId, TitanOperationStatus retrieveEdgeStatus) { - if (retrieveEdgeStatus == TitanOperationStatus.NOT_FOUND) { - // create new edge - Either vertexById = titanDao.getVertexById(componentUid); - if (vertexById.isRight()) { - return vertexById; - } - GraphVertex originVertex = vertexById.left().value(); - Map edgeProps = new EnumMap<>(EdgePropertyEnum.class); - List instList = new ArrayList<>(); - instList.add(instUniqueId); - edgeProps.put(EdgePropertyEnum.INSTANCES, instList); - - log.debug("Create new edge {} between {} and {} and properties {} ", edgeLabel, metadataVertex.getUniqueId(), originVertex.getUniqueId(), edgeProps); - TitanOperationStatus edgeResult = titanDao.createEdge(metadataVertex, originVertex, edgeLabel, edgeProps); - return edgeResult == TitanOperationStatus.OK ? Either.left(metadataVertex) : Either.right(edgeResult); - } - // error - log.debug("Failed to fetch edge with label {} and to vertex with id {} error {} ", edgeLabel, componentUid, retrieveEdgeStatus); - return Either.right(retrieveEdgeStatus); - } - - private TitanOperationStatus removeInstanceEdgeLogError(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, TitanOperationStatus retrieveEdgeStatus) { - if (retrieveEdgeStatus == TitanOperationStatus.NOT_FOUND) { - log.debug("No edge {} to remove between container {} and origin {}", edgeLabel, metadataVertex.getUniqueId(), componentUid); - } else { - // error - log.debug("Failed to fetch edge with label {} and to vertex with id {} error {} ", edgeLabel, componentUid, retrieveEdgeStatus); - } - return retrieveEdgeStatus; - } - - public void removeAllAllotedEdges(String uniqueId) { - Either vertexById = titanDao.getVertexById(uniqueId); - if (vertexById.isLeft()) { - GraphVertex originVertex = vertexById.left().value(); - TitanVertex vertex = originVertex.getVertex(); - Iterator edges = vertex.edges(Direction.OUT, EdgeLabelEnum.ALLOTTED_OF.name()); - while ( edges != null && edges.hasNext() ){ - Edge edge = edges.next(); - edge.remove(); - } - } - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java deleted file mode 100644 index 967fc16c49..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java +++ /dev/null @@ -1,962 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.DerivedNodeTypeResolver; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.springframework.beans.factory.annotation.Qualifier; - -import java.util.*; -import java.util.regex.Pattern; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("node-type-operation") -public class NodeTypeOperation extends ToscaElementOperation { - public final static Pattern uuidNewVersion = Pattern.compile("^\\d{1,}.1"); - public final static Pattern uuidNormativeNewVersion = Pattern.compile("^\\d{1,}.0"); - private static final Logger log = Logger.getLogger(NodeTypeOperation.class); - private DerivedNodeTypeResolver derivedResourceResolver; - - - public NodeTypeOperation(@Qualifier("derived-resource-resolver") DerivedNodeTypeResolver derivedNodeTypeResolver) { - this.derivedResourceResolver = derivedNodeTypeResolver; - } - - public Either createNodeType(NodeType nodeType) { - - Either result = null; - - nodeType.generateUUID(); - - //Set missing props such as names, default lifecycle state, dates etc... - nodeType = getResourceMetaDataFromResource(nodeType); - - //Set unique ID - String resourceUniqueId = nodeType.getUniqueId(); - if (resourceUniqueId == null) { - resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId(); - nodeType.setUniqueId(resourceUniqueId); - } - - // get derived from resources - List derivedResources = null; - Either, StorageOperationStatus> derivedResourcesResult = findDerivedResources(nodeType); - if (derivedResourcesResult.isRight()) { - result = Either.right(derivedResourcesResult.right().value()); - return result; - } else { - derivedResources = derivedResourcesResult.left().value(); - } - - //Create Vertext Object and fill according to given NodeType - GraphVertex nodeTypeVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE); - fillToscaElementVertexData(nodeTypeVertex, nodeType, JsonParseFlagEnum.ParseAll); - - //Create Node Type in Graph - Either createdVertex = titanDao.createVertex(nodeTypeVertex); - if (createdVertex.isRight()) { - TitanOperationStatus status = createdVertex.right().value(); - log.error("Error returned after creating resource data node {}. status returned is ", nodeTypeVertex, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - nodeTypeVertex = createdVertex.left().value(); - - StorageOperationStatus assosiateCommon = assosiateCommonForToscaElement(nodeTypeVertex, nodeType, derivedResources); - if (assosiateCommon != StorageOperationStatus.OK) { - result = Either.right(assosiateCommon); - return result; - } - - StorageOperationStatus associateDerived = assosiateToDerived(nodeTypeVertex, derivedResources); - if (associateDerived != StorageOperationStatus.OK) { - result = Either.right(associateDerived); - return result; - } - StorageOperationStatus associateCategory = assosiateResourceMetadataToCategory(nodeTypeVertex, nodeType); - if (associateCategory != StorageOperationStatus.OK) { - result = Either.right(associateCategory); - return result; - } - - StorageOperationStatus associateAttributes = associateAttributesToResource(nodeTypeVertex, nodeType, derivedResources); - if (associateAttributes != StorageOperationStatus.OK) { - result = Either.right(associateAttributes); - return result; - } - - StorageOperationStatus associateRequirements = associateRequirementsToResource(nodeTypeVertex, nodeType, derivedResources); - if (associateRequirements != StorageOperationStatus.OK) { - result = Either.right(associateRequirements); - return result; - } - - StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(nodeTypeVertex, nodeType, derivedResources); - if (associateCapabilities != StorageOperationStatus.OK) { - result = Either.right(associateCapabilities); - return result; - } - StorageOperationStatus associateCapabilitiesProps = associateCapabilitiesPropertiesToResource(nodeTypeVertex, nodeType, derivedResources); - if (associateCapabilitiesProps != StorageOperationStatus.OK) { - result = Either.right(associateCapabilitiesProps); - return result; - } - - StorageOperationStatus associateInterfaces = associateInterfacesToResource(nodeTypeVertex, nodeType, derivedResources); - if (associateInterfaces != StorageOperationStatus.OK) { - result = Either.right(associateInterfaces); - return result; - } - - StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(nodeTypeVertex, nodeType, derivedResources); - if (addAdditionalInformation != StorageOperationStatus.OK) { - result = Either.right(addAdditionalInformation); - return result; - } - result = Either.left(nodeType); - return result; - - } - - private StorageOperationStatus associateInterfacesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.INTERFACE_ARTIFACTS); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map interfacArtsAll = dataFromDerived.left().value(); - - Map interfacArts = nodeType.getInterfaceArtifacts(); - if (interfacArts != null) { - interfacArtsAll.putAll(interfacArts); - } - if (!interfacArtsAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INTERFACE_ARTIFACTS, EdgeLabelEnum.INTERFACE_ARTIFACTS, interfacArtsAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - @Override - public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { - - Either componentByLabelAndId = getComponentByLabelAndId(uniqueId, ToscaElementTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata); - if (componentByLabelAndId.isRight()) { - return Either.right(componentByLabelAndId.right().value()); - } - GraphVertex componentV = componentByLabelAndId.left().value(); - - return getToscaElement(componentV, componentParametersView); - - } - - // ------------------------------------------------------------- - @Override - public Either getToscaElement(GraphVertex componentV, ComponentParametersView componentParametersView) { - NodeType toscaElement; - toscaElement = convertToComponent(componentV); - TitanOperationStatus status = null; - if (!componentParametersView.isIgnoreUsers()) { - status = setCreatorFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = setLastModifierFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreProperties()) { - status = setResourcePropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK && status != TitanOperationStatus.NOT_FOUND) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreAttributesFrom()) { - status = setResourceAttributesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreDerivedFrom()) { - status = setResourceDerivedFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreCategories()) { - status = setResourceCategoryFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreRequirements()) { - status = setResourceRequirementsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - log.error("Failed to set requirement of resource {}. status is {}", componentV.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreCapabilities()) { - status = setResourceCapabilitiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreArtifacts()) { - status = setArtifactsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreAdditionalInformation()) { - status = setAdditionalInformationFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreInterfaces()) { - status = setInterfacesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreAllVersions()) { - status = setAllVersions(componentV, toscaElement); - if (status != TitanOperationStatus.OK && status != TitanOperationStatus.NOT_FOUND) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreCapabiltyProperties()) { - status = setComponentCapPropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - return Either.left(toscaElement); - } - - private TitanOperationStatus setComponentCapPropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES_PROPERTIES); - if (result.isLeft()) { - toscaElement.setCapabilitiesProperties(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setInterfacesFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE_ARTIFACTS); - if (result.isLeft()) { - toscaElement.setInterfaceArtifacts(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - protected TitanOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { - return setResourceCapabilitiesFromGraph(componentV, (NodeType) toscaElement); - } - - private TitanOperationStatus setResourceCapabilitiesFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES); - if (result.isLeft()) { - toscaElement.setCapabilities(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setResourceDerivedFromGraph(GraphVertex componentV, NodeType toscaElement) { - List derivedFromList = new ArrayList<>(); - - TitanOperationStatus listFromGraphStatus = findResourcesPathRecursively(componentV, derivedFromList); - if (TitanOperationStatus.OK != listFromGraphStatus) { - return listFromGraphStatus; - } - - if (!derivedFromList.isEmpty()) { - if (derivedFromList.size() > 1) { - List lastDerivedFrom = new ArrayList<>(); - lastDerivedFrom.add(derivedFromList.get(1)); - toscaElement.setDerivedFrom(lastDerivedFrom); - toscaElement.setDerivedList(derivedFromList); - } else { - toscaElement.setDerivedFrom(null); - toscaElement.setDerivedList(derivedFromList); - } - - } - return TitanOperationStatus.OK; - } - - protected TitanOperationStatus findResourcesPathRecursively(GraphVertex nodeTypeV, List resourcesPathList) { - Either parentResourceRes = titanDao.getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - resourcesPathList.add((String) nodeTypeV.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME)); - while (parentResourceRes.isLeft()) { - - GraphVertex parent = parentResourceRes.left().value(); - resourcesPathList.add((String) parent.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME)); - parentResourceRes = titanDao.getChildVertex(parent, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - } - TitanOperationStatus operationStatus = parentResourceRes.right().value(); - - if (operationStatus != TitanOperationStatus.NOT_FOUND) { - return operationStatus; - } else { - return TitanOperationStatus.OK; - } - - } - - protected TitanOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { - return setResourceRequirementsFromGraph(componentV, (NodeType) toscaElement); - } - - private TitanOperationStatus setResourceRequirementsFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.REQUIREMENTS); - if (result.isLeft()) { - toscaElement.setRequirements(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setResourceAttributesFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ATTRIBUTES); - if (result.isLeft()) { - toscaElement.setAttributes(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setResourcePropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.PROPERTIES); - if (result.isLeft()) { - toscaElement.setProperties(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private StorageOperationStatus assosiateToDerived(GraphVertex nodeTypeVertex, List derivedResources) { - for (GraphVertex derivedV : derivedResources) { - TitanOperationStatus createEdge = titanDao.createEdge(nodeTypeVertex, derivedV, EdgeLabelEnum.DERIVED_FROM, null); - if (createEdge != TitanOperationStatus.OK) { - log.trace("Failed to associate resource {} to derived with id {}", nodeTypeVertex.getUniqueId(), derivedV.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(createEdge); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus addAdditionalInformationToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ADDITIONAL_INFORMATION); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map addInformationAll = dataFromDerived.left().value(); - - Map addInformation = nodeType.getAdditionalInformation(); - if (addInformation != null) { - ToscaDataDefinition.mergeDataMaps(addInformationAll, addInformation); - } - if (!addInformationAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, addInformationAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateCapabilitiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map capabiltiesAll = dataFromDerived.left().value(); - - Map capabilties = nodeType.getCapabilities(); - if (capabilties != null) { - if (capabiltiesAll == null) { - capabiltiesAll = new HashMap<>(); - } - capabilties.values().forEach(l -> { - l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildCapabilityUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - }); - - ToscaDataDefinition.mergeDataMaps(capabiltiesAll, capabilties); - capabiltiesAll.values().forEach(l -> { - l.getListToscaDataDefinition().forEach(c -> { - List capabilitySources = c.getCapabilitySources(); - if (capabilitySources == null) { - capabilitySources = new ArrayList<>(); - } - capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); - c.setCapabilitySources(capabilitySources); - }); - }); - } - capabiltiesAll.values().forEach(l -> { - l.getListToscaDataDefinition().forEach(c -> { - List capabilitySources = c.getCapabilitySources(); - if (capabilitySources == null) { - capabilitySources = new ArrayList<>(); - } - capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); - c.setCapabilitySources(capabilitySources); - }); - }); - if (!capabiltiesAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES, EdgeLabelEnum.CAPABILITIES, capabiltiesAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateRequirementsToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.REQUIREMENTS); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map requirementsAll = dataFromDerived.left().value(); - - Map requirements = nodeType.getRequirements(); - if (requirements != null) { - if (requirementsAll == null) { - requirementsAll = new HashMap<>(); - } - requirements.values().forEach(l -> { - l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - }); - - ToscaDataDefinition.mergeDataMaps(requirementsAll, requirements); - - } - if (!requirementsAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.REQUIREMENTS, EdgeLabelEnum.REQUIREMENTS, requirementsAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateAttributesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ATTRIBUTES); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map attributesAll = dataFromDerived.left().value(); - - Map attributes = nodeType.getAttributes(); - if (attributes != null) { - attributes.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildAttributeUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - ToscaDataDefinition.mergeDataMaps(attributesAll, attributes); - } - if (!attributesAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ATTRIBUTES, EdgeLabelEnum.ATTRIBUTES, attributesAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - // TODO get from derived - private StorageOperationStatus associateCapabilitiesPropertiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List derivedResources) { - // // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES_PROPERTIES); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map propertiesAll = dataFromDerived.left().value(); - Map capabiltiesProps = nodeType.getCapabilitiesProperties(); - if (capabiltiesProps != null) { - capabiltiesProps.values().forEach(l -> { - if (l.getMapToscaDataDefinition() != null && l.getMapToscaDataDefinition().values() != null) { - Collection mapToscaDataDefinition = l.getMapToscaDataDefinition().values(); - mapToscaDataDefinition.stream().filter(p -> p != null && p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - } - }); - ToscaDataDefinition.mergeDataMaps(propertiesAll, capabiltiesProps); - } - if (!propertiesAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, propertiesAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public Either, StorageOperationStatus> findDerivedResources(NodeType nodeType) { - - List derivedResources = new ArrayList<>(); - List derivedFromResources = nodeType.getDerivedFrom(); - if (derivedFromResources != null && !derivedFromResources.isEmpty()) { - - for (String parentResource : derivedFromResources) { - Either, TitanOperationStatus> getParentResources = derivedResourceResolver.findDerivedResources(parentResource); - List resources = null; - if (getParentResources.isRight()) { - log.error("Cannot find parent resource by tosca resource name {} in the graph.", parentResource); - return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND); - - } else { - resources = getParentResources.left().value(); - if (resources == null || resources.size() == 0) { - log.error("Cannot find parent resource by tosca name {} in the graph. resources size is empty", parentResource); - return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND); - } else { - if (resources.size() > 1) { - return handleMultipleParent(parentResource, derivedResources, resources); - } else { - GraphVertex parentResourceData = resources.get(0); - derivedResources.add(parentResourceData); - } - } - - } - - } - } - return Either.left(derivedResources); - } - - Either, StorageOperationStatus> handleMultipleParent(String parentResource, List derivedResource, List fetchedDerivedResources) { - - Either, StorageOperationStatus> result = Either.left(derivedResource); - try { - fetchedDerivedResources.sort((d1, d2) -> { - return new Double(Double.parseDouble((String) d1.getMetadataProperty(GraphPropertyEnum.VERSION))).compareTo(Double.parseDouble((String) d2.getMetadataProperty(GraphPropertyEnum.VERSION))); - }); - - int actualHighestIndex = fetchedDerivedResources.size() - 1; - derivedResource.add(fetchedDerivedResources.get(actualHighestIndex)); - fetchedDerivedResources.remove(actualHighestIndex); - - StorageOperationStatus status = fixMultipleParent(fetchedDerivedResources); - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during handle multiple parent {}. Exception is {}", parentResource, e.getMessage()); - result = Either.right(StorageOperationStatus.GENERAL_ERROR); - } - return result; - } - - private StorageOperationStatus fixMultipleParent(List fetchedDerivedResources) { - StorageOperationStatus result = StorageOperationStatus.OK; - for (GraphVertex fetchedDerivedResource : fetchedDerivedResources) { - fetchedDerivedResource.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false); - Either updateVertexRes = titanDao.updateVertex(fetchedDerivedResource); - if (updateVertexRes.isRight()) { - TitanOperationStatus titatStatus = updateVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of node type {} to false. Status is {}", fetchedDerivedResource.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME), titatStatus); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus); - break; - } - } - return result; - } - - private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, NodeType nodeType) { - nodeTypeVertex.setLabel(VertexTypeEnum.NODE_TYPE); - - fillCommonMetadata(nodeTypeVertex, nodeType); - - return nodeTypeVertex; - } - - @Override - public Either deleteToscaElement(GraphVertex toscaElementVertex) { - Either nodeType = getToscaElement(toscaElementVertex, new ComponentParametersView()); - if (nodeType.isRight()) { - log.debug("Failed to fetch tosca element {} error {}", toscaElementVertex.getUniqueId(), nodeType.right().value()); - return nodeType; - } - TitanOperationStatus status = disassociateAndDeleteCommonElements(toscaElementVertex); - if (status != TitanOperationStatus.OK) { - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate capabilties for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES_PROPERTIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate capabilties properties for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.REQUIREMENTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ATTRIBUTES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate attributes for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INTERFACE_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate interface artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - toscaElementVertex.getVertex().remove(); - log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId()); - - return nodeType; - } - - @SuppressWarnings("unchecked") - @Override - public Either createToscaElement(ToscaElement toscaElement) { - return createNodeType((NodeType) toscaElement); - } - - @Override - protected TitanOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { - return setResourceCategoryFromGraph(vertexComponent, toscaElement); - } - - @Override - protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { - return validateResourceCategory(toscaElementToUpdate, elementV); - } - - @Override - protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV) { - - NodeType nodeType = (NodeType) toscaElementToUpdate; - - List derivedFromResources = nodeType.getDerivedFrom(); - - // now supported only single derived from - if (derivedFromResources != null && !derivedFromResources.isEmpty() && derivedFromResources.get(0) != null) { - String firstDerived = derivedFromResources.get(0); - boolean derivedFromGenericType = null != nodeType.getDerivedFromGenericType(); - Either childVertex = titanDao.getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - TitanOperationStatus getchieldError = childVertex.right().value(); - log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchieldError); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getchieldError); - } - GraphVertex firstDerivedInChain = childVertex.left().value(); - - String firstCurrentDerived = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME); - if (!firstDerived.equals(firstCurrentDerived) || derivedFromGenericType) { - - Map propertiesToMatch = new HashMap<>(); - propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - - propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, firstDerived); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - Either, TitanOperationStatus> getParentResources = titanDao.getByCriteria(VertexTypeEnum.NODE_TYPE, propertiesToMatch, JsonParseFlagEnum.NoParse); - - if (getParentResources.isRight()) { - TitanOperationStatus error = getParentResources.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch derived by criteria {}. error {} ", propertiesToMatch, error); - return DaoStatusConverter.convertTitanStatusToStorageStatus(error); - } - // must be only one - GraphVertex newDerivedV = getParentResources.left().value().get(0); - return updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, newDerivedV, false); - } - } - return StorageOperationStatus.OK; - } - - /** - * - * @param toscaElementToUpdate - * @param nodeTypeV - * @param preDerivedV - * @param newDerivedV - * @param mergeValues - * @return - */ - protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV, GraphVertex preDerivedV, GraphVertex newDerivedV, boolean mergeValues) { - Set preDerivedChainIdList = new HashSet(); - preDerivedChainIdList.add(preDerivedV.getUniqueId()); - Either childVertex = titanDao.getChildVertex(preDerivedV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - while (childVertex.isLeft()) { - GraphVertex currentChield = childVertex.left().value(); - preDerivedChainIdList.add(currentChield.getUniqueId()); - childVertex = titanDao.getChildVertex(currentChield, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - } - - List derivedResources = new ArrayList<>(); - derivedResources.add(newDerivedV); - StorageOperationStatus updateStatus = updateDataFromNewDerived(derivedResources, nodeTypeV, (NodeType) toscaElementToUpdate, mergeValues, preDerivedChainIdList); - if (updateStatus != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update data for {} from new derived {} ", nodeTypeV.getUniqueId(), newDerivedV.getUniqueId(), updateStatus); - return updateStatus; - } - - Either deleteEdge = titanDao.deleteEdge(nodeTypeV, preDerivedV, EdgeLabelEnum.DERIVED_FROM); - if (deleteEdge.isRight()) { - TitanOperationStatus deleteError = deleteEdge.right().value(); - log.debug("Failed to disassociate element {} from derived {} , error {}", nodeTypeV.getUniqueId(), preDerivedV.getUniqueId(), deleteError); - return DaoStatusConverter.convertTitanStatusToStorageStatus(deleteError); - } - - titanDao.createEdge(nodeTypeV, newDerivedV, EdgeLabelEnum.DERIVED_FROM, new HashMap<>()); - - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateDerivedDataByType(EdgeLabelEnum edgeLabel, GraphVertex nodeTypeV, NodeType nodeToUpdate, List newDerived) { - - switch (edgeLabel) { - case CAPABILITIES: - return associateCapabilitiesToResource(nodeTypeV, nodeToUpdate, newDerived); - case REQUIREMENTS: - return associateRequirementsToResource(nodeTypeV, nodeToUpdate, newDerived); - case PROPERTIES: - return associatePropertiesToResource(nodeTypeV, nodeToUpdate, newDerived); - case ATTRIBUTES: - return associateAttributesToResource(nodeTypeV, nodeToUpdate, newDerived); - case ADDITIONAL_INFORMATION: - return addAdditionalInformationToResource(nodeTypeV, nodeToUpdate, newDerived); - case CAPABILITIES_PROPERTIES: - return associateCapabilitiesPropertiesToResource(nodeTypeV, nodeToUpdate, newDerived); - default: - return StorageOperationStatus.OK; - } - - } - - private StorageOperationStatus updateDataFromNewDerived(List newDerived, GraphVertex nodeTypeV, NodeType nodeToUpdate, boolean mergeValues, Set preDerivedChainIdList) { - EnumSet edgeLabels = EnumSet.of(EdgeLabelEnum.CAPABILITIES, EdgeLabelEnum.REQUIREMENTS, EdgeLabelEnum.PROPERTIES, EdgeLabelEnum.ATTRIBUTES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.ADDITIONAL_INFORMATION); - StorageOperationStatus status = null; - for (EdgeLabelEnum edge : edgeLabels) { - status = updateDataByType(newDerived, nodeTypeV, edge, nodeToUpdate, mergeValues, preDerivedChainIdList); - if (status != StorageOperationStatus.OK) { - break; - } - } - return status; - - } - - private StorageOperationStatus updateDataByType(List newDerivedList, GraphVertex nodeTypeV, EdgeLabelEnum label, NodeType nodeElement, boolean mergeValues, Set preDerivedChainIdList) { - log.debug("Update data from derived for element {} type {}", nodeTypeV.getUniqueId(), label); - Either dataFromGraph = getDataVertex(nodeTypeV, label); - if (dataFromGraph.isRight()) { - if (TitanOperationStatus.NOT_FOUND == dataFromGraph.right().value()) - return associateDerivedDataByType(label, nodeTypeV, nodeElement, newDerivedList); - return DaoStatusConverter.convertTitanStatusToStorageStatus(dataFromGraph.right().value()); - } - GraphVertex dataV = dataFromGraph.left().value(); - - Map mapFromGraph = (Map) dataV.getJson(); - Map valuesFrmPrev = null; - if (isSimpleHierarchy(label)) { - if (mergeValues) { - valuesFrmPrev = mapFromGraph.entrySet().stream().filter(e -> e.getValue().getOwnerId() != null).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); - } - mapFromGraph.entrySet().removeIf(e -> preDerivedChainIdList.contains(e.getValue().getOwnerId())); - } else { - final Map valuesFrmPrevFinal = new HashMap<>(); - mapFromGraph.entrySet().stream().forEach(e -> { - T value = e.getValue(); - value = ToscaDataDefinition.removeAndCollectByOwnerId(value, preDerivedChainIdList); - valuesFrmPrevFinal.put(e.getKey(), value); - }); - valuesFrmPrev = valuesFrmPrevFinal; - mapFromGraph.entrySet().removeIf(e->e.getValue().isEmpty()); - } - - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(newDerivedList, label); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map dataFromDerivedAll = dataFromDerived.left().value(); - - Either, String> merged = ToscaDataDefinition.mergeDataMaps(dataFromDerivedAll, mapFromGraph); - if (merged.isRight()) { - log.debug("property {} cannot be overriden", merged.right().value()); - return StorageOperationStatus.INVALID_PROPERTY; - } - if (mergeValues && valuesFrmPrev != null) { - valuesFrmPrev.entrySet().forEach(e -> { - T newData = merged.left().value().get(e.getKey()); - if (newData != null) { - if (isSimpleHierarchy(label)) { - e.getValue().mergeFunction(newData, true); - }else{ - e.getValue().updateIfExist(newData, true); - } - } - }); - } - dataV.setJson(dataFromDerivedAll); - Either updateDataV = updateOrCopyOnUpdate(dataV, nodeTypeV, label); - if (updateDataV.isRight()) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(updateDataV.right().value()); - } - return StorageOperationStatus.OK; - } - - private boolean isSimpleHierarchy(EdgeLabelEnum label) { - switch (label) { - case PROPERTIES: - case ATTRIBUTES: - case ADDITIONAL_INFORMATION: - case ARTIFACTS: - case GROUPS: - case INPUTS: - return true; - default: - return false; - } - } - - @Override - public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { - fillMetadata(elementV, (NodeType) toscaElementToUpdate); - } - - public Either shouldUpdateDerivedVersion(ToscaElement toscaElementToUpdate, GraphVertex nodeTypeV) { - NodeType nodeType = (NodeType) toscaElementToUpdate; - - Either childVertex = titanDao.getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - TitanOperationStatus getchildError = childVertex.right().value(); - if (getchildError == TitanOperationStatus.NOT_FOUND) { - log.debug("derived resource for element {} not found", nodeTypeV.getUniqueId()); - return Either.right(StorageOperationStatus.OK); - } - - log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchildError); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getchildError)); - } - GraphVertex firstDerivedInChain = childVertex.left().value(); - - String currentVersion = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.VERSION); - - Map props = new HashMap<>(); - props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, nodeType.getDerivedFrom().get(0)); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - Map propsHasNot = new HashMap<>(); - propsHasNot.put(GraphPropertyEnum.IS_DELETED, true); - Either, TitanOperationStatus> byCriteria = titanDao.getByCriteria(VertexTypeEnum.NODE_TYPE, props, propsHasNot, JsonParseFlagEnum.NoParse); - if (byCriteria.isRight()) { - log.debug("Failed to fetch derived by props {} error {}", props, byCriteria.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value())); - } - List lastDerived = byCriteria.left().value(); - // now supported only one derived!!! Change in future!(Evg) - GraphVertex derivedFromHighest = lastDerived.get(0); - String highestVersion = (String) derivedFromHighest.getMetadataProperty(GraphPropertyEnum.VERSION); - if (!highestVersion.equals(currentVersion)) { - - // need to update to latest version of derived from - StorageOperationStatus updateDerived = updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, derivedFromHighest, true); - - if (updateDerived != StorageOperationStatus.OK) { - log.debug("Failed to update {} to highest derived {} from error {}", nodeTypeV.getUniqueId(), derivedFromHighest.getUniqueId(), updateDerived); - return Either.right(updateDerived); - } - return getToscaElement(nodeTypeV.getUniqueId(), new ComponentParametersView()); - } - // no version changes - return Either.right(StorageOperationStatus.OK); - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperation.java deleted file mode 100644 index efbac3301e..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperation.java +++ /dev/null @@ -1,62 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.utils.MapUtil; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; -import org.openecomp.sdc.common.log.wrappers.Logger; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -@org.springframework.stereotype.Component -public class PolicyOperation { - - private static final Logger log = Logger.getLogger(PolicyOperation.class.getName()); - private TopologyTemplateOperation topologyTemplateOperation; - private TitanDao titanDao; - - public PolicyOperation(TopologyTemplateOperation topologyTemplateOperation, TitanDao titanDao) { - this.topologyTemplateOperation = topologyTemplateOperation; - this.titanDao = titanDao; - } - - /** - * updates a list of policy properties by overriding the existing ones with the same name - * @param containerComponent the container of the policy of which its properties are to be updated - * @param policyId the id of the policy of which its properties are to be updated - * @param propertiesToUpdate the policy properties to update - * @return the update operation status - */ - public StorageOperationStatus updatePolicyProperties(Component containerComponent, String policyId, List propertiesToUpdate) { - log.debug("#updatePolicyProperties - updating the properties of policy {} in component {}", policyId, containerComponent.getUniqueId()); - PolicyDefinition policy = containerComponent.getPolicyById(policyId); - return titanDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse) - .either(containerVertex -> updatePolicyProperties(containerVertex, policy, propertiesToUpdate), - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - private StorageOperationStatus updatePolicyProperties(GraphVertex container, PolicyDefinition policy, List propertiesToUpdate) { - List policyProperties = policy.getProperties(); - List updatedPolicyProperties = updatePolicyProperties(policyProperties, propertiesToUpdate); - policy.setProperties(updatedPolicyProperties); - return topologyTemplateOperation.updatePolicyOfToscaElement(container, policy); - } - - private List updatePolicyProperties(List currentPolicyProperties, List toBeUpdatedProperties) { - Map currPropsByName = MapUtil.toMap(currentPolicyProperties, PropertyDataDefinition::getName); - overrideCurrentPropertiesWithUpdatedProperties(currPropsByName, toBeUpdatedProperties); - return new ArrayList<>(currPropsByName.values()); - } - - private void overrideCurrentPropertiesWithUpdatedProperties(Map currPropsByName, List toBeUpdatedProperties) { - toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop)); - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/RequirementOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/RequirementOperation.java deleted file mode 100644 index 1fd37500bf..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/RequirementOperation.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.RequirementDefinition; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -@org.springframework.stereotype.Component("requirement-operation") -public class RequirementOperation extends BaseOperation { - private static final Logger LOGGER = LoggerFactory.getLogger(RequirementOperation.class); - - public Either, StorageOperationStatus> addRequirement( - String componentId, - List requirementDefinitions) { - return addOrUpdateRequirements( componentId, requirementDefinitions, false); - } - - public Either, StorageOperationStatus> updateRequirement( - String componentId, - List requirementDefinitions) { - return addOrUpdateRequirements( componentId, requirementDefinitions, true); - } - - - private Either, StorageOperationStatus> addOrUpdateRequirements(String componentId, - List requirementDefinitions, - boolean isUpdateAction) { - - StorageOperationStatus statusRes = performUpdateToscaAction(isUpdateAction, - componentId, Collections - .singletonList(convertToListRequirementDataDefinition(requirementDefinitions))); - if (!statusRes.equals(StorageOperationStatus.OK)) { - titanDao.rollback(); - LOGGER.error("Failed to find the parent capability of capability type {}." - + " status is {}", componentId, statusRes); - return Either.right(statusRes); - } - titanDao.commit(); - return Either.left(requirementDefinitions); - } - - public StorageOperationStatus deleteRequirements(Component component, - String requirementToDelete) { - return deleteToscaDataElements(component.getUniqueId(), - EdgeLabelEnum.REQUIREMENTS, Collections.singletonList(requirementToDelete)); - } - - private static ListRequirementDataDefinition convertToListRequirementDataDefinition( - List requirementDefinitions) { - List requirementDataDefinitions = - new ArrayList<>(requirementDefinitions); - return new ListRequirementDataDefinition(requirementDataDefinitions); - } - - private StorageOperationStatus performUpdateToscaAction(boolean isUpdate, - String componentId, List toscaDataList) { - if (isUpdate) { - return updateToscaDataOfToscaElement(componentId, EdgeLabelEnum.REQUIREMENTS, - VertexTypeEnum.REQUIREMENTS, toscaDataList, JsonPresentationFields.CAPABILITY); - } else { - return addToscaDataToToscaElement(componentId, EdgeLabelEnum.REQUIREMENTS, - VertexTypeEnum.REQUIREMENTS, toscaDataList, JsonPresentationFields.CAPABILITY); - } - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperation.java deleted file mode 100644 index 5ddc5287ed..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperation.java +++ /dev/null @@ -1,1624 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.google.gson.reflect.TypeToken; -import fj.data.Either; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang.builder.ReflectionToStringBuilder; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentInstanceProperty; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.DistributionStatusEnum; -import org.openecomp.sdc.be.model.GroupDefinition; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.utils.CapabilityRequirementNameResolver; -import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; -import org.openecomp.sdc.be.model.operations.StorageException; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.api.Constants; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; -import org.springframework.beans.factory.annotation.Autowired; - -import java.lang.reflect.Type; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("topology-template-operation") -public class TopologyTemplateOperation extends ToscaElementOperation { - - private static final Logger log = Logger.getLogger(TopologyTemplateOperation.class); - private Set nodeTypeSet = new HashSet<>(Arrays.asList(OriginTypeEnum.VFC, OriginTypeEnum.CP, OriginTypeEnum.VL, OriginTypeEnum.Configuration, OriginTypeEnum.VFCMT)); - - @Autowired - private ArchiveOperation archiveOperation; - - public Either createTopologyTemplate(TopologyTemplate topologyTemplate) { - Either result = null; - - topologyTemplate.generateUUID(); - - topologyTemplate = getResourceMetaDataFromResource(topologyTemplate); - String resourceUniqueId = topologyTemplate.getUniqueId(); - if (resourceUniqueId == null) { - resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId(); - topologyTemplate.setUniqueId(resourceUniqueId); - } - - GraphVertex topologyTemplateVertex = new GraphVertex(); - topologyTemplateVertex = fillMetadata(topologyTemplateVertex, topologyTemplate, JsonParseFlagEnum.ParseAll); - - Either createdVertex = titanDao.createVertex(topologyTemplateVertex); - if (createdVertex.isRight()) { - TitanOperationStatus status = createdVertex.right().value(); - log.debug("Error returned after creating topology template data node {}. status returned is ", topologyTemplateVertex, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - - topologyTemplateVertex = createdVertex.left().value(); - - StorageOperationStatus assosiateCommon = assosiateCommonForToscaElement(topologyTemplateVertex, topologyTemplate, null); - if (assosiateCommon != StorageOperationStatus.OK) { - result = Either.right(assosiateCommon); - return result; - } - - StorageOperationStatus associateCategory = assosiateMetadataToCategory(topologyTemplateVertex, topologyTemplate); - if (associateCategory != StorageOperationStatus.OK) { - result = Either.right(associateCategory); - return result; - } - - StorageOperationStatus associateInputs = associateInputsToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInputs != StorageOperationStatus.OK) { - result = Either.right(associateInputs); - return result; - } - StorageOperationStatus associateGroups = associateGroupsToComponent(topologyTemplateVertex, topologyTemplate); - if (associateGroups != StorageOperationStatus.OK) { - result = Either.right(associateGroups); - return result; - } - StorageOperationStatus associatePolicies = associatePoliciesToComponent(topologyTemplateVertex, topologyTemplate); - if (associatePolicies != StorageOperationStatus.OK) { - result = Either.right(associatePolicies); - return result; - } - StorageOperationStatus associateInstAttr = associateInstAttributesToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInstAttr != StorageOperationStatus.OK) { - result = Either.right(associateInstAttr); - return result; - } - StorageOperationStatus associateInstProperties = associateInstPropertiesToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInstProperties != StorageOperationStatus.OK) { - result = Either.right(associateInstProperties); - return result; - } - StorageOperationStatus associateInstInputs = associateInstInputsToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInstProperties != StorageOperationStatus.OK) { - result = Either.right(associateInstInputs); - return result; - } - StorageOperationStatus associateInstGroups = associateInstGroupsToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInstGroups != StorageOperationStatus.OK) { - result = Either.right(associateInstInputs); - return result; - } - - StorageOperationStatus associateRequirements = associateRequirementsToResource(topologyTemplateVertex, topologyTemplate); - if (associateRequirements != StorageOperationStatus.OK) { - result = Either.right(associateRequirements); - return result; - } - - StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(topologyTemplateVertex, topologyTemplate); - if (associateCapabilities != StorageOperationStatus.OK) { - result = Either.right(associateCapabilities); - return result; - } - - StorageOperationStatus associateArtifacts = associateTopologyTemplateArtifactsToComponent(topologyTemplateVertex, topologyTemplate); - if (associateArtifacts != StorageOperationStatus.OK) { - result = Either.right(associateArtifacts); - return result; - } - - StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(topologyTemplateVertex, topologyTemplate); - if (addAdditionalInformation != StorageOperationStatus.OK) { - result = Either.right(addAdditionalInformation); - return result; - } - StorageOperationStatus associateCapProperties = associateCapPropertiesToResource(topologyTemplateVertex, topologyTemplate); - if (associateCapProperties != StorageOperationStatus.OK) { - result = Either.right(associateCapProperties); - return result; - } - - StorageOperationStatus associateInterfaces = associateInterfacesToComponent(topologyTemplateVertex, topologyTemplate); - if (associateInterfaces != StorageOperationStatus.OK) { - result = Either.right(associateInterfaces); - return result; - } - - StorageOperationStatus associatePathProperties = associateForwardingPathToResource(topologyTemplateVertex, topologyTemplate); - if (associateCapProperties != StorageOperationStatus.OK) { - result = Either.right(associatePathProperties); - return result; - } - - - return Either.left(topologyTemplate); - - } - - private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - return associatePoliciesToComponent(nodeTypeVertex, topologyTemplate.getPolicies()); - } - - private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, Map policies) { - if (policies != null && !policies.isEmpty()) { - policies.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.POLICIES, EdgeLabelEnum.POLICIES, policies); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateForwardingPathToResource(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { - Map forwardingPaths = topologyTemplate.getForwardingPaths(); - return associateForwardingPathToComponent(topologyTemplateVertex, forwardingPaths); - } - - private StorageOperationStatus associateNodeFilterToResource(GraphVertex topologyTemplateVertex, - TopologyTemplate topologyTemplate) { - Map nodeFilters = - topologyTemplate.getNodeFilterComponents(); - return associateNodeFiltersToComponent(topologyTemplateVertex, nodeFilters); - } - - private StorageOperationStatus associateCapPropertiesToResource(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { - Map calculatedCapProperties = topologyTemplate - .getCalculatedCapabilitiesProperties(); - if (MapUtils.isNotEmpty(calculatedCapProperties)) { - Either associateElementToData = associateElementToData - (topologyTemplateVertex, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, - EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, calculatedCapProperties); - if (associateElementToData.isRight()) { - return associateElementToData.right().value(); - } - } - - Map capabilitiesProperties = topologyTemplate.getCapabilitiesProperties(); - if (MapUtils.isNotEmpty(capabilitiesProperties)) { - Either associateElementToData = - associateElementToData(topologyTemplateVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, - EdgeLabelEnum.CAPABILITIES_PROPERTIES, capabilitiesProperties); - if (associateElementToData.isRight()) { - return associateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateCapabilitiesToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map calculatedCapabilities = topologyTemplate.getCalculatedCapabilities(); - if (calculatedCapabilities != null && !calculatedCapabilities.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, calculatedCapabilities); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map fullfilledCapabilities = topologyTemplate.getFullfilledCapabilities(); - if (fullfilledCapabilities != null && !fullfilledCapabilities.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_CAPABILITIES, EdgeLabelEnum.FULLFILLED_CAPABILITIES, fullfilledCapabilities); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map capabilities = topologyTemplate.getCapabilities(); - if(MapUtils.isNotEmpty(capabilities)) { - Either associateElementToData = - associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES, - EdgeLabelEnum.CAPABILITIES, capabilities); - if (associateElementToData.isRight()) { - return associateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - - } - - private StorageOperationStatus associateRequirementsToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map calculatedRequirements = topologyTemplate.getCalculatedRequirements(); - if (calculatedRequirements != null && !calculatedRequirements.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calculatedRequirements); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map fullfilledRequirements = topologyTemplate.getFullfilledRequirements(); - if (fullfilledRequirements != null && !fullfilledRequirements.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_REQUIREMENTS, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, fullfilledRequirements); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map requirements = topologyTemplate.getRequirements(); - if(MapUtils.isNotEmpty(requirements)) { - Either associateElementToData = - associateElementToData(nodeTypeVertex, VertexTypeEnum.REQUIREMENTS, - EdgeLabelEnum.REQUIREMENTS, requirements); - if (associateElementToData.isRight()) { - return associateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateTopologyTemplateArtifactsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map addInformation = topologyTemplate.getServiceApiArtifacts(); - - if (addInformation != null && !addInformation.isEmpty()) { - addInformation.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { - String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); - a.setUniqueId(uniqueId); - }); - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.SERVICE_API_ARTIFACTS, EdgeLabelEnum.SERVICE_API_ARTIFACTS, addInformation); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map instArtifacts = topologyTemplate.getInstDeploymentArtifacts(); - - if (instArtifacts != null && !instArtifacts.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, instArtifacts); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - Map instInfoArtifacts = topologyTemplate.getInstanceArtifacts(); - - if (instInfoArtifacts != null && !instInfoArtifacts.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INSTANCE_ARTIFACTS, EdgeLabelEnum.INSTANCE_ARTIFACTS, instInfoArtifacts); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus addAdditionalInformationToResource(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - - Map addInformation = topologyTemplate.getAdditionalInformation(); - - if (addInformation != null && !addInformation.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, addInformation); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateInstPropertiesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map instProps = topologyTemplate.getInstProperties(); - return associateInstPropertiesToComponent(nodeTypeVertex, instProps); - } - - public StorageOperationStatus associateInstInputsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map instProps = topologyTemplate.getInstInputs(); - return associateInstInputsToComponent(nodeTypeVertex, instProps); - } - - public StorageOperationStatus associateInstGroupsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map instGroups = topologyTemplate.getInstGroups(); - return associateInstGroupsToComponent(nodeTypeVertex, instGroups); - } - - - public StorageOperationStatus associateInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map instProps) { - if (instProps != null && !instProps.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_PROPERTIES, EdgeLabelEnum.INST_PROPERTIES, instProps); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateInstInputsToComponent(GraphVertex nodeTypeVertex, Map instInputs) { - if (instInputs != null && !instInputs.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_INPUTS, EdgeLabelEnum.INST_INPUTS, instInputs); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateInstGroupsToComponent(GraphVertex nodeTypeVertex, Map instGroups) { - if (instGroups != null && !instGroups.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_GROUPS, EdgeLabelEnum.INST_GROUPS, instGroups); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - - public StorageOperationStatus deleteInstInputsToComponent(GraphVertex nodeTypeVertex, Map instInputs) { - - if (instInputs != null && !instInputs.isEmpty()) { - instInputs.entrySet().forEach(i -> { - List uniqueKeys = new ArrayList<>(i.getValue().getMapToscaDataDefinition().keySet()); - List pathKeys = new ArrayList<>(); - pathKeys.add(i.getKey()); - - StorageOperationStatus status = deleteToscaDataDeepElements(nodeTypeVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, uniqueKeys, pathKeys, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - return; - } - }); - } - - return StorageOperationStatus.OK; - } - - public StorageOperationStatus addInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map instInputs) { - - if (instInputs != null && !instInputs.isEmpty()) { - instInputs.entrySet().forEach(i -> { - StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(nodeTypeVertex, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, i.getValue(), i.getKey()); - if (status != StorageOperationStatus.OK) { - return; - } - }); - } - - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex, Map instArtifacts) { - return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - } - - public StorageOperationStatus associateInstArtifactsToComponent(GraphVertex nodeTypeVertex, Map instArtifacts) { - return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INSTANCE_ARTIFACTS, EdgeLabelEnum.INSTANCE_ARTIFACTS); - } - - private StorageOperationStatus associateInstanceArtifactsToComponent(GraphVertex nodeTypeVertex, Map instProps, VertexTypeEnum vertexType, EdgeLabelEnum edgeLabel) { - if (instProps != null && !instProps.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, vertexType, edgeLabel, instProps); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateOrAddCalcCapReqToComponent(GraphVertex nodeTypeVertex, Map calcRequirements, Map calcCapabilty, Map calculatedCapabilitiesProperties) { - if (calcRequirements != null && !calcRequirements.isEmpty()) { - Either assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calcRequirements); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - Map fullFilled = new HashMap<>(); - assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_REQUIREMENTS, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, fullFilled); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - if (calcCapabilty != null && !calcCapabilty.isEmpty()) { - Either assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAPABILITIES, EdgeLabelEnum.CALCULATED_CAPABILITIES, calcCapabilty); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - Map fullFilled = new HashMap<>(); - assosiateElementToData = associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.FULLFILLED_CAPABILITIES, EdgeLabelEnum.FULLFILLED_CAPABILITIES, fullFilled); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - if (calculatedCapabilitiesProperties != null && !calculatedCapabilitiesProperties.isEmpty()) { - return associateOrAddElementToData(nodeTypeVertex, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, - EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, calculatedCapabilitiesProperties) - .right() - .on(v -> StorageOperationStatus.OK); - } - return StorageOperationStatus.OK; - } - - private Either associateOrAddElementToData(GraphVertex nodeTypeVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { - return titanDao.getChildVertex(nodeTypeVertex, edgeLabelEnum, JsonParseFlagEnum.ParseJson) - .either(dataVertex -> addElementsToComponent(nodeTypeVertex, dataVertex, vertexTypeEnum, edgeLabelEnum, dataMap), - status -> associateElementToDataIfNotFound(status, nodeTypeVertex, vertexTypeEnum, edgeLabelEnum, dataMap)); - } - - private Either associateElementToDataIfNotFound(TitanOperationStatus status, GraphVertex nodeTypeVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { - if (status == TitanOperationStatus.NOT_FOUND) { - return associateElementToData(nodeTypeVertex, vertexTypeEnum, edgeLabelEnum, dataMap); - } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - private Either addElementsToComponent(GraphVertex nodeTypeVertex, GraphVertex dataVertex, VertexTypeEnum vertexTypeEnum, EdgeLabelEnum edgeLabelEnum, Map dataMap) { - Optional error = dataMap.entrySet() - .stream() - .map(e -> addElementToComponent(nodeTypeVertex.getUniqueId(), vertexTypeEnum, edgeLabelEnum, e)) - .filter(s -> s != StorageOperationStatus.OK) - .findFirst(); - if (error.isPresent()) { - return Either.right(error.get()); - } - return Either.left(dataVertex); - } - - private StorageOperationStatus associateInstAttributesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map instAttr = topologyTemplate.getInstAttributes(); - return associateInstAttributeToComponent(nodeTypeVertex, instAttr); - } - - public StorageOperationStatus associateForwardingPathToComponent(GraphVertex nodeTypeVertex, Map forwardingPathMap) { - if (forwardingPathMap != null && !forwardingPathMap.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.FORWARDING_PATH, EdgeLabelEnum.FORWARDING_PATH, forwardingPathMap); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateInstAttributeToComponent(GraphVertex nodeTypeVertex, Map instAttr) { - if (instAttr != null && !instAttr.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_ATTRIBUTES, EdgeLabelEnum.INST_ATTRIBUTES, instAttr); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateGroupsToComponent(GraphVertex nodeTypeVertex, Map groups) { - - if (groups != null && !groups.isEmpty()) { - groups.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.GROUPS, EdgeLabelEnum.GROUPS, groups); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateGroupsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - return associateGroupsToComponent(nodeTypeVertex, topologyTemplate.getGroups()); - } - - public StorageOperationStatus associateInputsToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - Map inputs = topologyTemplate.getInputs(); - return associateInputsToComponent(nodeTypeVertex, inputs, topologyTemplate.getUniqueId()); - } - - public StorageOperationStatus associateInputsToComponent(GraphVertex nodeTypeVertex, Map inputs, String id) { - if (inputs != null && !inputs.isEmpty()) { - inputs.values().stream().filter(e -> e.getUniqueId() == null).forEach(e -> e.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(id, e.getName()))); - - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INPUTS, EdgeLabelEnum.INPUTS, inputs); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate, JsonParseFlagEnum flag) { - nodeTypeVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); - fillCommonMetadata(nodeTypeVertex, topologyTemplate); - if (flag == JsonParseFlagEnum.ParseAll || flag == JsonParseFlagEnum.ParseJson) { - nodeTypeVertex.setJson(topologyTemplate.getCompositions()); - } - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.CSAR_UUID, topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, topologyTemplate.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)); - - return nodeTypeVertex; - - } - - private StorageOperationStatus assosiateMetadataToCategory(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - if (topologyTemplate.getResourceType() == null) { - // service - return associateServiceMetadataToCategory(nodeTypeVertex, topologyTemplate); - } else { - // VF - return assosiateResourceMetadataToCategory(nodeTypeVertex, topologyTemplate); - } - } - - private StorageOperationStatus associateServiceMetadataToCategory(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) { - String categoryName = topologyTemplate.getCategories().get(0).getName(); - Either category = categoryOperation.getCategory(categoryName, VertexTypeEnum.SERVICE_CATEGORY); - if (category.isRight()) { - log.trace("NO category {} for service {}", categoryName, topologyTemplate.getUniqueId()); - return StorageOperationStatus.CATEGORY_NOT_FOUND; - } - GraphVertex categoryV = category.left().value(); - TitanOperationStatus createEdge = titanDao.createEdge(nodeTypeVertex, categoryV, EdgeLabelEnum.CATEGORY, new HashMap<>()); - if (createEdge != TitanOperationStatus.OK) { - log.trace("Failed to associate resource {} to category {} with id {}", topologyTemplate.getUniqueId(), categoryName, categoryV.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(createEdge); - } - return StorageOperationStatus.OK; - } - - @Override - public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { - JsonParseFlagEnum parseFlag = componentParametersView.detectParseFlag(); - - Either componentByLabelAndId = getComponentByLabelAndId(uniqueId, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, parseFlag); - if (componentByLabelAndId.isRight()) { - return Either.right(componentByLabelAndId.right().value()); - } - GraphVertex componentV = componentByLabelAndId.left().value(); - - return getToscaElement(componentV, componentParametersView); - - } - // ------------------------------------------------------------- - - public Either getToscaElement(GraphVertex componentV, ComponentParametersView componentParametersView) { - TopologyTemplate toscaElement; - - toscaElement = convertToTopologyTemplate(componentV); - TitanOperationStatus status; - if (!componentParametersView.isIgnoreUsers()) { - status = setCreatorFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = setLastModifierFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreCategories()) { - status = setTopologyTempalteCategoriesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - if (!componentParametersView.isIgnoreArtifacts()) { - TitanOperationStatus storageStatus = setAllArtifactsFromGraph(componentV, toscaElement); - if (storageStatus != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(storageStatus)); - } - } - if (!componentParametersView.isIgnoreComponentInstancesProperties()) { - status = setComponentInstancesPropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreCapabilities()) { - status = setCapabilitiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreRequirements()) { - status = setRequirementsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreAllVersions()) { - status = setAllVersions(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!componentParametersView.isIgnoreAdditionalInformation()) { - status = setAdditionalInformationFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - if (!componentParametersView.isIgnoreGroups()) { - status = setGroupsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - } - if (!componentParametersView.isIgnorePolicies()) { - status = setPoliciesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - } - if (!componentParametersView.isIgnoreComponentInstances()) { - status = setInstGroupsFromGraph(componentV, toscaElement); - - //Mark all CIs that has archived origins - archiveOperation.setArchivedOriginsFlagInComponentInstances(componentV); - - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - } - if (!componentParametersView.isIgnoreInputs()) { - status = setInputsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - } - if (!componentParametersView.isIgnoreProperties()) { - status = setPropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - } - - if (!componentParametersView.isIgnoreComponentInstancesInputs()) { - status = setComponentInstancesInputsFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - - if (!componentParametersView.isIgnoreCapabiltyProperties()) { - status = setComponentInstancesCapPropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - - if (!componentParametersView.isIgnoreForwardingPath()) { - status = setForwardingGraphPropertiesFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - - if (!componentParametersView.isIgnoreNodeFilter()) { - status = setNodeFilterComponentFromGraph(componentV, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - - } - } - - if (!componentParametersView.isIgnoreInterfaces()) { - TitanOperationStatus storageStatus = setInterfacesFromGraph(componentV, toscaElement); - if (storageStatus != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(storageStatus)); - - } - } - - if (!componentParametersView.isIgnoreComponentInstancesInterfaces()) { - TitanOperationStatus storageStatus = - setComponentInstancesInterfacesFromGraph(componentV, toscaElement); - if (storageStatus != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(storageStatus)); - } - } - - if (!componentParametersView.isIgnoreDataType()) { - TitanOperationStatus storageStatus = setDataTypesFromGraph(componentV, toscaElement); - if (storageStatus != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(storageStatus)); - } - } - - return Either.left(toscaElement); - } - - private TitanOperationStatus setDataTypesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.DATA_TYPES); - if (result.isLeft()) { - toscaElement.setDataTypes(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setPoliciesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.POLICIES); - if (result.isLeft()) { - toscaElement.setPolicies(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setInterfacesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE); - if (result.isLeft()) { - topologyTemplate.setInterfaces(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - - private TitanOperationStatus setComponentInstancesInterfacesFromGraph(GraphVertex componentV, - TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = - getDataFromGraph(componentV, EdgeLabelEnum.INST_INTERFACES); - if (result.isLeft()) { - result.left().value().entrySet().forEach(entry -> topologyTemplate - .addComponentInstanceInterfaceMap(entry.getKey(), entry.getValue())); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private StorageOperationStatus associateInterfacesToComponent(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) { - Map interfaceMap = topologyTemplate.getInterfaces(); - if (interfaceMap != null && !interfaceMap.isEmpty()) { - Either assosiateElementToData = associateElementToData(topologyTemplateVertex, VertexTypeEnum.INTERFACE, EdgeLabelEnum.INTERFACE, interfaceMap); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - public StorageOperationStatus associateNodeFiltersToComponent(GraphVertex nodeTypeVertex, - Map filterMaps) { - if (filterMaps != null && !filterMaps.isEmpty()) { - Either assosiateElementToData = associateElementToData - (nodeTypeVertex, VertexTypeEnum.NODE_FILTER_TEMPLATE, - EdgeLabelEnum.NODE_FILTER_TEMPLATE, filterMaps); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private TitanOperationStatus setForwardingGraphPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.FORWARDING_PATH); - if (result.isLeft()) { - topologyTemplate.setForwardingPaths(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - - private TitanOperationStatus setComponentInstancesCapPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); - if (result.isLeft()) { - topologyTemplate.setCalculatedCapabilitiesProperties(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - Either, TitanOperationStatus> capPropResult = - getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES_PROPERTIES); - if (capPropResult.isLeft()) { - topologyTemplate.setCapabilitiesProperties(capPropResult.left().value()); - } else { - if (capPropResult.right().value() != TitanOperationStatus.NOT_FOUND) { - return capPropResult.right().value(); - } - } - - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setPropertiesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.PROPERTIES); - if (result.isLeft()) { - toscaElement.setProperties(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setInstGroupsFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_GROUPS); - if (result.isLeft()) { - topologyTemplate.setInstGroups(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setComponentInstancesPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_PROPERTIES); - if (result.isLeft()) { - topologyTemplate.setInstProperties(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setComponentInstancesInputsFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INST_INPUTS); - if (result.isLeft()) { - topologyTemplate.setInstInputs(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setNodeFilterComponentFromGraph(GraphVertex componentV, - TopologyTemplate topologyTemplate) { - Either, TitanOperationStatus> result = - getDataFromGraph(componentV, - EdgeLabelEnum.NODE_FILTER_TEMPLATE); - if (result.isLeft()) { - topologyTemplate.setNodeFilterComponents(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - @Override - protected TitanOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (result.isLeft()) { - ((TopologyTemplate) toscaElement).setCalculatedRequirements(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - result = getDataFromGraph(componentV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (result.isLeft()) { - ((TopologyTemplate) toscaElement).setFullfilledRequirements(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - Either, TitanOperationStatus> requirementResult = - getDataFromGraph(componentV, EdgeLabelEnum.REQUIREMENTS); - if (requirementResult.isLeft()) { - toscaElement.setRequirements(requirementResult.left().value()); - } else { - if (requirementResult.right().value() != TitanOperationStatus.NOT_FOUND) { - return requirementResult.right().value(); - } - } - return TitanOperationStatus.OK; - - } - - protected TitanOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (result.isLeft()) { - ((TopologyTemplate) toscaElement).setCalculatedCapabilities(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - result = getDataFromGraph(componentV, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (result.isLeft()) { - ((TopologyTemplate) toscaElement).setFullfilledCapabilities(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - Either, TitanOperationStatus> capabilitiesResult = - getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES); - if (capabilitiesResult.isLeft()) { - toscaElement.setCapabilities(capabilitiesResult.left().value()); - } else { - if (capabilitiesResult.right().value() != TitanOperationStatus.NOT_FOUND) { - return capabilitiesResult.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setAllArtifactsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - TitanOperationStatus storageStatus = setArtifactsFromGraph(componentV, toscaElement); - if (storageStatus != TitanOperationStatus.OK) { - return storageStatus; - } - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.SERVICE_API_ARTIFACTS); - if (result.isLeft()) { - toscaElement.setServiceApiArtifacts(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - Either, TitanOperationStatus> resultInstArt = getDataFromGraph(componentV, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - if (resultInstArt.isLeft()) { - toscaElement.setInstDeploymentArtifacts(resultInstArt.left().value()); - } else { - if (resultInstArt.right().value() != TitanOperationStatus.NOT_FOUND) { - return resultInstArt.right().value(); - } - } - Either, TitanOperationStatus> instanceArt = getDataFromGraph(componentV, EdgeLabelEnum.INSTANCE_ARTIFACTS); - if (instanceArt.isLeft()) { - toscaElement.setInstanceArtifacts(instanceArt.left().value()); - } else { - if (instanceArt.right().value() != TitanOperationStatus.NOT_FOUND) { - return instanceArt.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setInputsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INPUTS); - if (result.isLeft()) { - toscaElement.setInputs(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setGroupsFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.GROUPS); - if (result.isLeft()) { - toscaElement.setGroups(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setTopologyTempalteCategoriesFromGraph(GraphVertex componentV, ToscaElement toscaElement) { - List categories = new ArrayList<>(); - - switch (componentV.getType()) { - case RESOURCE: - return setResourceCategoryFromGraph(componentV, toscaElement); - case SERVICE: - return setServiceCategoryFromGraph(componentV, toscaElement, categories); - - default: - log.debug("Not supported component type {} ", componentV.getType()); - break; - } - return TitanOperationStatus.OK; - } - - private TitanOperationStatus setServiceCategoryFromGraph(GraphVertex componentV, ToscaElement toscaElement, List categories) { - Either childVertex = titanDao.getChildVertex(componentV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug("failed to fetch {} for tosca element with id {}, error {}", EdgeLabelEnum.CATEGORY, componentV.getUniqueId(), childVertex.right().value()); - return childVertex.right().value(); - } - GraphVertex categoryV = childVertex.left().value(); - Map metadataProperties = categoryV.getMetadataProperties(); - CategoryDefinition category = new CategoryDefinition(); - category.setUniqueId(categoryV.getUniqueId()); - category.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); - category.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); - - Type listTypeCat = new TypeToken>() { - }.getType(); - List iconsfromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS.getProperty()), listTypeCat); - category.setIcons(iconsfromJsonCat); - categories.add(category); - toscaElement.setCategories(categories); - - return TitanOperationStatus.OK; - } - - @SuppressWarnings("unchecked") - private TopologyTemplate convertToTopologyTemplate(GraphVertex componentV) { - - TopologyTemplate topologyTemplate = super.convertToComponent(componentV); - - Map json = (Map) componentV.getJson(); - topologyTemplate.setCompositions(json); - - return topologyTemplate; - } - - @Override - public Either deleteToscaElement(GraphVertex toscaElementVertex) { - Either nodeType = getToscaElement(toscaElementVertex, new ComponentParametersView()); - if (nodeType.isRight()) { - log.debug("Failed to fetch tosca element {} error {}", toscaElementVertex.getUniqueId(), nodeType.right().value()); - return nodeType; - } - TitanOperationStatus status = disassociateAndDeleteCommonElements(toscaElementVertex); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_ATTRIBUTES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instances attributes for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_PROPERTIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instances properties for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INPUTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instances inputs for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.GROUPS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate groups for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.POLICIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate policies for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_GROUPS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instance groups for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INPUTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate inputs for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INPUTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instance inputs for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES_PROPERTIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate capabilities properties for {} error {}", toscaElementVertex.getUniqueId(), status); - Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_CAPABILITIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate calculated capabiliites for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FULLFILLED_CAPABILITIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate fullfilled capabilities for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate calculated capabiliites properties for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CALCULATED_REQUIREMENTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate calculated requirements for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FULLFILLED_REQUIREMENTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate full filled requirements for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instance artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.SERVICE_API_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate service api artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FORWARDING_PATH); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate service api artifacts for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INTERFACE); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate interfaces for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INSTANCE_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instance artifact for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, - EdgeLabelEnum.REQUIREMENTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate requirements for {} error {}", - toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, - EdgeLabelEnum.CAPABILITIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate capabilities for {} error {}", - toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INST_INTERFACES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disassociate instances interfaces for {} error {}", toscaElementVertex.getUniqueId(), status); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - toscaElementVertex.getVertex().remove(); - log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId()); - - return nodeType; - } - - @SuppressWarnings("unchecked") - @Override - public Either createToscaElement(ToscaElement toscaElement) { - return createTopologyTemplate((TopologyTemplate) toscaElement); - } - - @Override - protected TitanOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { - return setTopologyTempalteCategoriesFromGraph(vertexComponent, toscaElement); - } - - @Override - protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { - // Product isn't supported now!! - // TODO add for Product - if (toscaElementToUpdate.getComponentType() == ComponentTypeEnum.SERVICE) { - return validateServiceCategory(toscaElementToUpdate, elementV); - } else { - // Resource - return validateResourceCategory(toscaElementToUpdate, elementV); - } - } - - @Override - protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex updateElementV) { - // not relevant now for topology template - return StorageOperationStatus.OK; - } - - @Override - public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { - fillMetadata(elementV, (TopologyTemplate) toscaElementToUpdate, flag); - } - - private StorageOperationStatus validateServiceCategory(T toscaElementToUpdate, GraphVertex elementV) { - StorageOperationStatus status = StorageOperationStatus.OK; - List newCategoryList = toscaElementToUpdate.getCategories(); - CategoryDefinition newCategory = newCategoryList.get(0); - - Either childVertex = titanDao.getChildVertex(elementV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug("failed to fetch {} for tosca element with id {}, error {}", EdgeLabelEnum.CATEGORY, elementV.getUniqueId(), childVertex.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(childVertex.right().value()); - } - - GraphVertex categoryV = childVertex.left().value(); - Map metadataProperties = categoryV.getMetadataProperties(); - String categoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); - - String newCategoryName = newCategory.getName(); - if (newCategoryName != null && !newCategoryName.equals(categoryNameCurrent)) { - // the category was changed - Either getCategoryVertex = categoryOperation.getCategory(newCategoryName, VertexTypeEnum.SERVICE_CATEGORY); - - if (getCategoryVertex.isRight()) { - return getCategoryVertex.right().value(); - } - GraphVertex newCategoryV = getCategoryVertex.left().value(); - status = moveCategoryEdge(elementV, newCategoryV); - log.debug("Going to update the category of the resource from {} to {}. status is {}", categoryNameCurrent, newCategory, status); - } - return status; - } - - public Either updateDistributionStatus(String uniqueId, User user, DistributionStatusEnum distributionStatus) { - - Either result = null; - String userId = user.getUserId(); - Either getRes = findUserVertex(userId); - GraphVertex userVertex = null; - GraphVertex serviceVertex = null; - if (getRes.isRight()) { - TitanOperationStatus status = getRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Cannot find user {} in the graph. status is {}", userId, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - userVertex = getRes.left().value(); - getRes = titanDao.getVertexById(uniqueId, JsonParseFlagEnum.ParseMetadata); - if (getRes.isRight()) { - TitanOperationStatus status = getRes.right().value(); - log.debug("Cannot find service {} in the graph. status is {}", uniqueId, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - serviceVertex = getRes.left().value(); - Iterator edgeIterator = serviceVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER.name()); - if (edgeIterator.hasNext()) { - log.debug("Remove existing edge from user to component {}. Edge type is {}", userId, uniqueId, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER); - edgeIterator.next().remove(); - } - } - if (result == null) { - TitanOperationStatus status = titanDao.createEdge(userVertex, serviceVertex, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER, null); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to associate user {} to component {}. Edge type is {}", userId, uniqueId, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - serviceVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, distributionStatus.name()); - long lastUpdateDate = System.currentTimeMillis(); - serviceVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, lastUpdateDate); - Either updateRes = titanDao.updateVertex(serviceVertex); - if (updateRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateRes.right().value())); - } - } - if (result == null) { - result = Either.left(serviceVertex); - } - return result; - } - - /** - * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId - * - * @param componentId - * @param instanceId - * @param capabilityName - * @param capabilityType - * @param ownerId - * @return - */ - public Either, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityName, String capabilityType, String ownerId) { - - Either, StorageOperationStatus> result = null; - Map mapPropertiesDataDefinition = null; - Either componentByLabelAndId = getComponentByLabelAndId(componentId, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.NoParse); - if (componentByLabelAndId.isRight()) { - result = Either.right(componentByLabelAndId.right().value()); - } - if (componentByLabelAndId.isLeft()) { - Either, TitanOperationStatus> getDataRes = getDataFromGraph(componentByLabelAndId.left().value(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES); - if (getDataRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getDataRes.right().value())); - } else { - mapPropertiesDataDefinition = getDataRes.left().value(); - } - } - if (isNotEmptyMapOfProperties(instanceId, mapPropertiesDataDefinition)) { - result = Either.left(findComponentInstanceCapabilityProperties(instanceId, capabilityName, capabilityType, ownerId, mapPropertiesDataDefinition.get(instanceId).getMapToscaDataDefinition())); - } - return result; - } - - public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceId, MapCapabilityProperty instanceProperties) { - return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instanceProperties, componentInstanceId); - } - - public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, - String componentInstanceId, - MapInterfaceDataDefinition instanceInterfaces) { - if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) { - return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), - EdgeLabelEnum.INST_INTERFACES, instanceInterfaces, componentInstanceId); - } - return StorageOperationStatus.OK; - } - - - private boolean isNotEmptyMapOfProperties(String instanceId, Map mapPropertiesDataDefinition) { - return MapUtils.isNotEmpty(mapPropertiesDataDefinition) && - mapPropertiesDataDefinition.get(instanceId) != null && - MapUtils.isNotEmpty(mapPropertiesDataDefinition.get(instanceId).getMapToscaDataDefinition()); - } - - private List findComponentInstanceCapabilityProperties(String instanceId, String capabilityName, String capabilityType, String ownerId, Map propertiesMap) { - List capPropsList = null; - for (Entry capProp : propertiesMap.entrySet()) { - if (isBelongingPropertyMap(instanceId, capabilityName, capabilityType, ownerId, capProp)) { - Map capMap = capProp.getValue().getMapToscaDataDefinition(); - if (capMap != null && !capMap.isEmpty()) { - capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()); - break; - } - } - } - if (capPropsList == null) { - capPropsList = new ArrayList<>(); - } - return capPropsList; - } - - private boolean isBelongingPropertyMap(String instanceId, String capabilityName, String capabilityType, String ownerId, Entry capProp) { - if (capProp != null) { - String[] path = capProp.getKey().split(ModelConverter.CAP_PROP_DELIM); - if (path.length < 4) { - log.debug("wrong key format for capabilty, key {}", capProp); - return false; - } - return path[path.length - 2].equals(capabilityType) && path[path.length - 1].equals(capabilityName) && path[1].equals(ownerId) && path[0].equals(instanceId); - } - return false; - } - - public StorageOperationStatus addPolicyToToscaElement(GraphVertex componentV, PolicyDefinition policyDefinition, int counter) { - fillPolicyDefinition(componentV, policyDefinition, counter); - return addToscaDataToToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyDefinition, JsonPresentationFields.UNIQUE_ID); - } - - public StorageOperationStatus addPoliciesToToscaElement(GraphVertex componentV, List policies) { - return addToscaDataToToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policies, JsonPresentationFields.UNIQUE_ID); - } - - public StorageOperationStatus updatePolicyOfToscaElement(GraphVertex componentV, PolicyDefinition policyDefinition) { - return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyDefinition, JsonPresentationFields.UNIQUE_ID); - } - - public StorageOperationStatus updatePoliciesOfToscaElement(GraphVertex componentV, List policiesDefinitions) { - return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policiesDefinitions, JsonPresentationFields.UNIQUE_ID); - } - - public StorageOperationStatus removePolicyFromToscaElement(GraphVertex componentV, String policyId) { - return deleteToscaDataElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyId, JsonPresentationFields.UNIQUE_ID); - } - - public StorageOperationStatus updateGroupOfToscaElement(GraphVertex componentV, GroupDefinition groupDefinition) { - return updateToscaDataOfToscaElement(componentV, EdgeLabelEnum.GROUPS, VertexTypeEnum.GROUPS, groupDefinition, JsonPresentationFields.NAME); - } - - private void fillPolicyDefinition(GraphVertex componentV, PolicyDefinition policyDefinition, int counter) { - String policyName = buildSubComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME), policyDefinition.getPolicyTypeName(), counter); - policyDefinition.setName(policyName); - policyDefinition.setInvariantName(policyName); - policyDefinition.setComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME)); - policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(componentV.getUniqueId(), policyName)); - policyDefinition.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID()); - policyDefinition.setPolicyUUID(UniqueIdBuilder.generateUUID()); - } - - public static String buildSubComponentName(String componentName, String subComponentTypeName, int counter) { - String normalizedComponentName = ValidationUtils.normalizeComponentInstanceName(componentName); - String typeSuffix = subComponentTypeName.substring(subComponentTypeName.lastIndexOf('.') + 1, subComponentTypeName.length()); - return normalizedComponentName + Constants.GROUP_POLICY_NAME_DELIMETER + typeSuffix + Constants.GROUP_POLICY_NAME_DELIMETER + counter; - } - - void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) { - if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) { - GraphVertex toscaElementV = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) - .left() - .on(this::throwStorageException); - if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) { - toscaElement.getComponentInstances().values().forEach(i -> CapabilityRequirementNameResolver.revertNamesOfCalculatedCapabilitiesRequirements(toscaElement, i.getUniqueId(), this::getOriginToscaElement)); - } - if (MapUtils.isNotEmpty(toscaElement.getGroups())) { - toscaElement.getGroups().values().forEach(g -> CapabilityRequirementNameResolver.revertNamesOfCalculatedCapabilitiesRequirements(toscaElement, g.getUniqueId(), this::getOriginToscaElement)); - } - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, toscaElement.getCalculatedCapabilities()); - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, toscaElement.getCalculatedRequirements()); - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, toscaElement.getCalculatedCapabilitiesProperties()); - } - } - - public void updateNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) { - if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) { - GraphVertex toscaElementV = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) - .left() - .on(this::throwStorageException); - if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) { - toscaElement.getComponentInstances().values().forEach(i -> CapabilityRequirementNameResolver.updateNamesOfCalculatedCapabilitiesRequirements(toscaElement, i.getUniqueId(), i.getNormalizedName(), this::getOriginToscaElement)); - } - if (MapUtils.isNotEmpty(toscaElement.getGroups())) { - toscaElement.getGroups().values().forEach(g -> CapabilityRequirementNameResolver.updateNamesOfCalculatedCapabilitiesRequirements(toscaElement, g.getUniqueId(), g.getName(), this::getOriginToscaElement)); - } - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, toscaElement.getCalculatedCapabilities()); - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, toscaElement.getCalculatedRequirements()); - topologyTemplateOperation.updateFullToscaData(toscaElementV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, toscaElement.getCalculatedCapabilitiesProperties()); - } - } - - private ToscaElement getOriginToscaElement(ComponentInstanceDataDefinition instance) { - log.debug("#getOriginToscaElement - origin name: {}", instance.getComponentName()); - ToscaElementTypeEnum elementType = detectToscaType(instance.getOriginType()); - Either getOriginRes; - if (elementType == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE) { - getOriginRes = this.getToscaElement(CapabilityRequirementNameResolver.getActualComponentUid(instance), getFilter()); - - } else { - getOriginRes = nodeTypeOperation.getToscaElement(CapabilityRequirementNameResolver.getActualComponentUid(instance), getFilter()); - } - if (getOriginRes.isRight()) { - log.debug("Failed to get an origin component with uniqueId {}", CapabilityRequirementNameResolver.getActualComponentUid(instance)); - throw new StorageException(getOriginRes.right().value()); - } - return getOriginRes.left().value(); - } - - private ToscaElementTypeEnum detectToscaType(OriginTypeEnum originType) { - log.debug("#detectToscaType - type: {}", originType); - if (nodeTypeSet.contains(originType)){ - return ToscaElementTypeEnum.NODE_TYPE; - } else { - return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE; - } - } - - private ComponentParametersView getFilter() { - ComponentParametersView filter = new ComponentParametersView(); - filter.setIgnoreCapabilities(false); - filter.setIgnoreCapabiltyProperties(false); - filter.setIgnoreRequirements(false); - return filter; - } - public void updateCapReqPropertiesOwnerId(String componentId, TopologyTemplate toscaElement) { - GraphVertex toscaElementV = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) - .left().on(this::throwStorageException); - updateCapOwnerId(toscaElement, componentId); - updateReqOwnerId(toscaElement, componentId); - updatePropertiesOwnerId(toscaElement, componentId); - topologyTemplateOperation - - .updateFullToscaData(toscaElementV, EdgeLabelEnum.CAPABILITIES, - VertexTypeEnum.CAPABILITIES, toscaElement.getCapabilities()); - topologyTemplateOperation - .updateFullToscaData(toscaElementV, EdgeLabelEnum.REQUIREMENTS, - VertexTypeEnum.REQUIREMENTS, toscaElement.getRequirements()); - topologyTemplateOperation - .updateFullToscaData(toscaElementV, EdgeLabelEnum.PROPERTIES, - VertexTypeEnum.PROPERTIES, toscaElement.getProperties()); - } - - private void updateCapOwnerId(ToscaElement toscaElement, String ownerId) { - if(MapUtils.isNotEmpty(toscaElement.getCapabilities())) { - toscaElement.getCapabilities().values().stream().flatMap(listCapDef -> listCapDef.getListToscaDataDefinition().stream()) - .forEach(capabilityDefinition -> capabilityDefinition.setOwnerId(ownerId)); - } - } - - private void updateReqOwnerId(ToscaElement toscaElement, String ownerId) { - if(MapUtils.isNotEmpty(toscaElement.getRequirements())) { - toscaElement.getRequirements().values().stream().flatMap(listReqDef -> listReqDef.getListToscaDataDefinition().stream()) - .forEach(requirementDefinition -> requirementDefinition.setOwnerId(ownerId)); - } - } - - private void updatePropertiesOwnerId(ToscaElement toscaElement, String ownerId) { - Map properties = toscaElement.getProperties(); - if(MapUtils.isNotEmpty(properties)) { - properties.values().forEach(propertyDataDefinition -> propertyDataDefinition.setParentUniqueId(ownerId)); - } - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaDataOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaDataOperation.java deleted file mode 100644 index 0abc0111bf..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaDataOperation.java +++ /dev/null @@ -1,25 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -@org.springframework.stereotype.Component("tosca-data-operation") -public class ToscaDataOperation extends BaseOperation { -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementLifecycleOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementLifecycleOperation.java deleted file mode 100644 index afad869bb1..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementLifecycleOperation.java +++ /dev/null @@ -1,1583 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang.StringUtils; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; -import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; -import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.DistributionStatusEnum; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; - -import java.util.*; -import java.util.stream.Collectors; - -@org.springframework.stereotype.Component("tosca-element-lifecycle-operation") - -/** - * Allows to perform lifecycle operations: checkin, checkout, submit for testing, start certification and certification process for tosca element - */ -public class ToscaElementLifecycleOperation extends BaseOperation { - - private static final String FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS = "Failed to delete last state edge. Status is {}. "; - private static final String FAILED_TO_GET_VERTICES = "Failed to get vertices by id {}. Status is {}. "; - public static final String VERSION_DELIMITER = "."; - public static final String VERSION_DELIMITER_REGEXP = "\\."; - - private static final Logger log = Logger.getLogger(ToscaElementLifecycleOperation.class); - - /** - * Performs changing a lifecycle state of tosca element from "checked out" or "ready for certification" to "checked in" - * - * @param currState - * @param toscaElementId - * @param modifierId - * @param ownerId - * @return - */ - public Either checkinToscaELement(LifecycleStateEnum currState, String toscaElementId, String modifierId, String ownerId) { - Either updateResult = null; - Either result = null; - Map vertices = null; - ToscaElementOperation operation; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckin(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - updateResult = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } else { - vertices = getVerticesRes.left().value(); - updateResult = checkinToscaELement(currState, vertices.get(toscaElementId), vertices.get(ownerId), vertices.get(modifierId), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - } - if (updateResult.isLeft()) { - operation = getToscaElementOperation(vertices.get(toscaElementId).getLabel()); - result = operation.getToscaElement(updateResult.left().value().getUniqueId()); - if (result.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated tosca element {}. Status is {}", toscaElementId, result.right().value()); - } - } else { - result = Either.right(updateResult.right().value()); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during checkin of tosca element {}. {} ", toscaElementId, e.getMessage()); - } - return result; - } - - /** - * Returns vertex presenting owner of tosca element specified by uniqueId - * - * @param toscaElementId - * @return - */ - public Either getToscaElementOwner(String toscaElementId) { - Either result = null; - GraphVertex toscaElement = null; - Either getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse); - if (getToscaElementRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value())); - } - if (result == null) { - toscaElement = getToscaElementRes.left().value(); - Iterator vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name()); - if (vertices == null || !vertices.hasNext()) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } else { - result = Either.left(convertToUser(vertices.next())); - } - } - return result; - } - - /** - * Returns vertex presenting owner of tosca element specified by uniqueId - * - * @param toscaElement - * @return - */ - public Either getToscaElementOwner(GraphVertex toscaElement) { - Either result = null; - Iterator vertices = toscaElement.getVertex().vertices(Direction.IN, EdgeLabelEnum.STATE.name()); - if (vertices == null || !vertices.hasNext()) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } else { - result = Either.left(convertToUser(vertices.next())); - } - return result; - } - - /** - * Performs checkout of a tosca element - * - * @param toscaElementId - * @param modifierId - * @param ownerId - * @return - */ - public Either checkoutToscaElement(String toscaElementId, String modifierId, String ownerId) { - Either result = null; - Map vertices = null; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckout(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - vertices = getVerticesRes.left().value(); - // update previous component if not certified - StorageOperationStatus status = updatePreviousVersion(vertices.get(toscaElementId), vertices.get(ownerId)); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update vertex with id {} . Status is {}. ", status); - result = Either.right(status); - } - } - if (result == null) { - result = cloneToscaElementForCheckout(vertices.get(toscaElementId), vertices.get(modifierId)); - if (result.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to checkout tosca element {}. Status is {} ", toscaElementId, result.right().value()); - } - - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during checkout tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - /** - * Performs undo checkout for tosca element - * - * @param toscaElementId - * @return - */ - public Either undoCheckout(String toscaElementId) { - Either result = null; - Either getToscaElementRes = null; - Iterator nextVersionComponentIter = null; - ToscaElementOperation operation; - Vertex preVersionVertex = null; - try { - getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata); - if (getToscaElementRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value())); - } - GraphVertex currVersionV = getToscaElementRes.left().value(); - if (result == null && hasPreviousVersion(currVersionV)) { - // find previous version - nextVersionComponentIter = currVersionV.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name()); - if (nextVersionComponentIter == null || !nextVersionComponentIter.hasNext()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch previous version of tosca element with name {}. ", currVersionV.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString()); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - if (result == null) { - preVersionVertex = nextVersionComponentIter.next().outVertex(); - StorageOperationStatus updateOldResourceResult = updateOldToscaElementBeforeUndoCheckout(preVersionVertex); - if (updateOldResourceResult != StorageOperationStatus.OK) { - result = Either.right(updateOldResourceResult); - } - } - } - if (result == null) { - StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRootByUndoCheckout((TitanVertex) preVersionVertex, currVersionV); - if (updateCatalogRes != StorageOperationStatus.OK) { - return Either.right(updateCatalogRes); - } - operation = getToscaElementOperation(currVersionV.getLabel()); - result = operation.deleteToscaElement(currVersionV); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during undo checkout tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - private boolean hasPreviousVersion(GraphVertex toscaElementVertex) { - boolean hasPreviousVersion = true; - String version = (String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION); - if (StringUtils.isEmpty(version) || "0.1".equals(version)) - hasPreviousVersion = false; - return hasPreviousVersion; - } - - /** - * Performs request certification for tosca element - * - * @param toscaElementId - * @param modifierId - * @param ownerId - * @return - */ - public Either requestCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) { - Either resultUpdate = null; - Either result = null; - GraphVertex toscaElement = null; - GraphVertex modifier = null; - GraphVertex owner; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - toscaElement = getVerticesRes.left().value().get(toscaElementId); - modifier = getVerticesRes.left().value().get(modifierId); - owner = getVerticesRes.left().value().get(ownerId); - - StorageOperationStatus status = handleRelationsUponRequestForCertification(toscaElement, modifier, owner); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations on certification request for tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - LifecycleStateEnum nextState = LifecycleStateEnum.READY_FOR_CERTIFICATION; - - toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); - toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - - resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); - if (resultUpdate.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set lifecycle for tosca elememt {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); - result = Either.right(resultUpdate.right().value()); - } - } - if (result == null) { - ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); - result = operation.getToscaElement(toscaElement.getUniqueId()); - } - return result; - - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during request certification tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - /** - * Starts certification of tosca element - * - * @param toscaElementId - * @param modifierId - * @param ownerId - * @return - */ - public Either startCertificationToscaElement(String toscaElementId, String modifierId, String ownerId) { - Either result = null; - Either resultUpdate = null; - GraphVertex toscaElement = null; - GraphVertex modifier = null; - GraphVertex owner; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - toscaElement = getVerticesRes.left().value().get(toscaElementId); - modifier = getVerticesRes.left().value().get(modifierId); - owner = getVerticesRes.left().value().get(ownerId); - - StorageOperationStatus status = handleRelationsUponCertification(toscaElement, modifier, owner); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations during certification of tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - LifecycleStateEnum nextState = LifecycleStateEnum.CERTIFICATION_IN_PROGRESS; - - toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); - toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - - resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); - if (resultUpdate.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Couldn't set lifecycle for component {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); - result = Either.right(resultUpdate.right().value()); - } - } - if (result == null) { - ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); - result = operation.getToscaElement(toscaElement.getUniqueId()); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during start certification tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - public Either certifyToscaElement(String toscaElementId, String modifierId, String ownerId) { - Either result = null; - Either cloneRes = null; - GraphVertex toscaElement = null; - GraphVertex modifier = null; - GraphVertex certifiedToscaElement = null; - Integer majorVersion = null; - - StorageOperationStatus status; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - toscaElement = getVerticesRes.left().value().get(toscaElementId); - modifier = getVerticesRes.left().value().get(modifierId); - majorVersion = getMajorVersion((String) toscaElement.getMetadataProperty(GraphPropertyEnum.VERSION)); - status = handleRelationsOfPreviousToscaElementBeforeCertifying(toscaElement, modifier, majorVersion); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations of previous tosca element before certifying {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - cloneRes = cloneToscaElementForCertify(toscaElement, modifier, majorVersion); - if (cloneRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element during certification. "); - result = Either.right(cloneRes.right().value()); - } - } - if (result == null) { - certifiedToscaElement = cloneRes.left().value(); - status = handleRelationsOfNewestCertifiedToscaElement(toscaElement, certifiedToscaElement); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations of newest certified tosca element {}. Status is {}. ", certifiedToscaElement.getUniqueId(), status); - } - } - if (result == null) { - return getToscaElementOperation(toscaElement.getLabel()).getToscaElement(certifiedToscaElement.getUniqueId()); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during certification tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - /** - * Deletes (marks as deleted) all tosca elements according received name and uuid - * - * @param vertexType - * @param componentType - * @param componentName - * @param uuid - * @return - */ - public Either deleteOldToscaElementVersions(VertexTypeEnum vertexType, ComponentTypeEnum componentType, String componentName, String uuid) { - - Either result = null; - ToscaElementOperation operation = getToscaElementOperation(componentType); - - try { - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.UUID, uuid); - properties.put(GraphPropertyEnum.NAME, componentName); - Either, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(vertexType, properties, JsonParseFlagEnum.ParseMetadata); - if (getToscaElementsRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value())); - } - if (result == null) { - result = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value()); - } - if (result == null) { - result = Either.left(true); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage()); - } - return result; - } - - /** - * Performs cancelation or failure of certification for received tosca element - * - * @param toscaElementId - * @param modifierId - * @param ownerId - * @param nextState - * @return - */ - public Either cancelOrFailCertification(String toscaElementId, String modifierId, String ownerId, LifecycleStateEnum nextState) { - Either result = null; - StorageOperationStatus status; - ToscaElementOperation operation = null; - GraphVertex toscaElement = null; - GraphVertex modifier = null; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - toscaElement = getVerticesRes.left().value().get(toscaElementId); - modifier = getVerticesRes.left().value().get(modifierId); - operation = getToscaElementOperation(toscaElement.getLabel()); - toscaElement.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - toscaElement.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifier.getUniqueId()); - toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); - - Either updateVertexRes = titanDao.updateVertex(toscaElement); - if (updateVertexRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update vertex {} . Status is {}. ", toscaElementId, updateVertexRes.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertexRes.right().value())); - } - } - if (result == null) { - // cancel certification process - status = handleRelationsUponCancelCertification(toscaElement, nextState); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations upon cancel certification {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - // fail certification - status = handleRelationsUponFailCertification(toscaElement, nextState); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations upon fail certification {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - result = operation.getToscaElement(toscaElementId); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during cancel or fail certification of tosca element {}. {}. ", toscaElementId, e.getMessage()); - } - return result; - } - - public Either findUser(String userId) { - return findUserVertex(userId); - } - - private Either markToscaElementsAsDeleted(ToscaElementOperation operation, List toscaElements) { - Either result = Either.left(true); - for (GraphVertex resourceToDelete : toscaElements) { - if (!((String) resourceToDelete.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals(LifecycleStateEnum.CERTIFIED.name())) { - Either deleteElementRes = operation.markComponentToDelete(resourceToDelete); - if (deleteElementRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete tosca element {}. Status is {}. ", resourceToDelete.getUniqueId(), deleteElementRes.right().value()); - result = Either.right(deleteElementRes.right().value()); - break; - } - } - } - return result; - } - - private StorageOperationStatus handleRelationsOfNewestCertifiedToscaElement(GraphVertex toscaElement, GraphVertex certifiedToscaElement) { - StorageOperationStatus result = null; - Edge foundEdge = null; - Iterator certReqUserEdgeIter = null; - // add rfc relation to preserve follower information - // get user of certification request - certReqUserEdgeIter = toscaElement.getVertex().edges(Direction.IN, GraphEdgeLabels.LAST_STATE.name()); - if (certReqUserEdgeIter == null || !certReqUserEdgeIter.hasNext()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. "); - result = StorageOperationStatus.NOT_FOUND; - } - if (result == null) { - TitanOperationStatus createVersionEdgeStatus = titanDao.createEdge(toscaElement, certifiedToscaElement, EdgeLabelEnum.VERSION, new HashMap<>()); - if (createVersionEdgeStatus != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create version edge from last element {} to new certified element {}. status=", toscaElement.getUniqueId(), certifiedToscaElement.getUniqueId(), - createVersionEdgeStatus); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(createVersionEdgeStatus); - } - } - if (result == null) { - if (certReqUserEdgeIter!=null) { - while (certReqUserEdgeIter.hasNext()) { - Edge edge = certReqUserEdgeIter.next(); - if (((String) titanDao.getProperty(edge, EdgePropertyEnum.STATE)).equals(LifecycleStateEnum.READY_FOR_CERTIFICATION.name())) { - foundEdge = edge; - break; - } - - } - } - if (foundEdge == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find rfc relation during certification clone. "); - result = StorageOperationStatus.NOT_FOUND; - } - } - if (result == null) { - TitanOperationStatus createEdgeRes = titanDao.createEdge(foundEdge.outVertex(), certifiedToscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, foundEdge); - if (createEdgeRes != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create rfc relation for component {}. status=", certifiedToscaElement.getUniqueId(), createEdgeRes); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus handleRelationsUponFailCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) { - StorageOperationStatus result = null; - TitanOperationStatus status = null; - Edge originEdge; - Vertex user = null; - if (nextState == LifecycleStateEnum.NOT_CERTIFIED_CHECKIN) { - // fail certification - // delete relation CERTIFICATION_IN_PROGRESS - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); - - Either deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties); - if (deleteResult.isRight()) { - status = deleteResult.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", status); - result = StorageOperationStatus.INCONSISTENCY; - } - if (result == null) { - // delete relation READY_FOR_CERTIFICATION - properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION); - deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); - if (deleteResult.isRight()) { - status = deleteResult.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - // delete relation NOT_CERTIFIED_CHECKIN (in order to change to STATE) - properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); - if (deleteResult.isRight()) { - status = deleteResult.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - // create new STATE relation NOT_CERTIFIED_CHECKIN - originEdge = deleteResult.left().value(); - user = originEdge.outVertex(); - status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - // delete relation LAST_MODIFIER (in order to change tester to designer) - deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - // create new LAST_MODIFIER relation - originEdge = deleteResult.left().value(); - status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.LAST_MODIFIER, originEdge); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus handleRelationsUponCancelCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) { - StorageOperationStatus result = null; - Edge originEdge; - if (nextState == LifecycleStateEnum.READY_FOR_CERTIFICATION) { - // delete relation CERTIFICATION_IN_PROGRESS - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); - Either deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties); - - if (deleteResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", deleteResult.right().value()); - result = StorageOperationStatus.INCONSISTENCY; - } - if (result == null) { - // delete relation READY_FOR_CERTIFICATION (LAST_STATE) - properties.put(GraphPropertyEnum.STATE, nextState); - deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties); - - if (deleteResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, deleteResult.right().value()); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - // create relation READY_FOR_CERTIFICATION (STATE) - originEdge = deleteResult.left().value(); - TitanOperationStatus status = titanDao.createEdge(originEdge.outVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status); - result = StorageOperationStatus.INCONSISTENCY; - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - } - return result; - } - - private StorageOperationStatus handleRelationsOfPreviousToscaElementBeforeCertifying(GraphVertex toscaElement, GraphVertex modifier, Integer majorVersion) { - StorageOperationStatus result = null; - if (majorVersion > 0) { - Either findRes = findLastCertifiedToscaElementVertex(toscaElement); - if (findRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch last certified tosca element {} . Status is {}. ", toscaElement.getMetadataProperty(GraphPropertyEnum.NAME), findRes.right().value()); - result = findRes.right().value(); - } - if (result == null) { - Vertex lastCertifiedVertex = findRes.left().value(); - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false); - TitanOperationStatus status = titanDao.updateVertexMetadataPropertiesWithJson(lastCertifiedVertex, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of tosca element {} to [{}]. Status is {}", toscaElement.getUniqueId(), false, status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - // remove previous certified version from the catalog - GraphVertex lastCertifiedV = new GraphVertex(); - lastCertifiedV.setVertex((TitanVertex) lastCertifiedVertex); - lastCertifiedV.setUniqueId((String) titanDao.getProperty((TitanVertex) lastCertifiedVertex, GraphPropertyEnum.UNIQUE_ID.getProperty())); - StorageOperationStatus res = updateEdgeToCatalogRoot(null, lastCertifiedV); - if (res != StorageOperationStatus.OK) { - return res; - } - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus handleRelationsUponRequestForCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { - TitanOperationStatus status; - StorageOperationStatus result = null; - - if (((String) toscaElement.getMetadataProperty(GraphPropertyEnum.STATE)).equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) { - // remove CHECKOUT relation - Either deleteRes = titanDao.deleteEdge(owner, toscaElement, EdgeLabelEnum.STATE); - if (deleteRes.isRight()) { - status = deleteRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge. Status is {}. ", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (result == null) { - // create CHECKIN relation - Map properties = new EnumMap<>(EdgePropertyEnum.class); - properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - } else { - status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); - if (status != TitanOperationStatus.OK) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - if (result == null) { - // create RFC relation - Map properties = new EnumMap<>(EdgePropertyEnum.class); - properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION); - status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus handleRelationsUponCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { - - StorageOperationStatus result = null; - TitanOperationStatus status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); - if (status != TitanOperationStatus.OK) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (result == null) { - Map properties = new EnumMap<>(EdgePropertyEnum.class); - properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); - status = titanDao.createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - if (result == null) { - Either updateRelationsRes = updateLastModifierEdge(toscaElement, owner, modifier); - if (updateRelationsRes.isRight()) { - result = updateRelationsRes.right().value(); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private Either findLastCertifiedToscaElementVertex(GraphVertex toscaElement) { - return findLastCertifiedToscaElementVertexRecursively(toscaElement.getVertex()); - } - - private Either findLastCertifiedToscaElementVertexRecursively(Vertex vertex) { - if (isCertifiedVersion((String) vertex.property(GraphPropertyEnum.VERSION.getProperty()).value())) { - return Either.left(vertex); - } - Iterator edgeIter = vertex.edges(Direction.IN, EdgeLabelEnum.VERSION.name()); - if (!edgeIter.hasNext()) { - return Either.right(StorageOperationStatus.NOT_FOUND); - } - return findLastCertifiedToscaElementVertexRecursively(edgeIter.next().outVertex()); - } - - private boolean isCertifiedVersion(String version) { - String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); - if (Integer.parseInt(versionParts[0]) > 0 && Integer.parseInt(versionParts[1]) == 0) { - return true; - } - return false; - } - - private StorageOperationStatus updateOldToscaElementBeforeUndoCheckout(Vertex previousVersionToscaElement) { - - StorageOperationStatus result = StorageOperationStatus.OK; - String previousVersion = (String) previousVersionToscaElement.property(GraphPropertyEnum.VERSION.getProperty()).value(); - if (!previousVersion.endsWith(".0")) { - try { - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update vertex of previous version of tosca element", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty())); - - Map propertiesToUpdate = new HashMap<>(); - propertiesToUpdate.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true); - Map jsonMetadataMap = JsonParserUtils.toMap((String) previousVersionToscaElement.property(GraphPropertyEnum.METADATA.getProperty()).value()); - jsonMetadataMap.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true); - propertiesToUpdate.put(GraphPropertyEnum.METADATA.getProperty(), JsonParserUtils.toJson(jsonMetadataMap)); - - titanDao.setVertexProperties(previousVersionToscaElement, propertiesToUpdate); - - Iterator edgesIter = previousVersionToscaElement.edges(Direction.IN, EdgeLabelEnum.LAST_STATE.name()); - if (!edgesIter.hasNext()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch last modifier vertex for tosca element {}. ", previousVersionToscaElement.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty())); - result = StorageOperationStatus.NOT_FOUND; - } else { - Edge lastStateEdge = edgesIter.next(); - Vertex lastModifier = lastStateEdge.outVertex(); - TitanOperationStatus replaceRes = titanDao.replaceEdgeLabel(lastModifier, previousVersionToscaElement, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE); - if (replaceRes != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to replace label from {} to {}. status = {}", EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE, replaceRes); - result = StorageOperationStatus.INCONSISTENCY; - if (replaceRes != TitanOperationStatus.INVALID_ID) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(replaceRes); - } - } - - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during update previous tosca element {} before undo checkout. {} ", e.getMessage()); - } - } - return result; - } - - private StorageOperationStatus updatePreviousVersion(GraphVertex toscaElementVertex, GraphVertex ownerVertex) { - StorageOperationStatus result = null; - String ownerId = (String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID); - String toscaElementId = toscaElementVertex.getUniqueId(); - if (!toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) { - toscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false); - Either updateVertexRes = titanDao.updateVertex(toscaElementVertex); - if (updateVertexRes.isRight()) { - TitanOperationStatus titatStatus = updateVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update tosca element vertex {}. Status is {}", toscaElementVertex.getUniqueId(), titatStatus); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus); - } - Either deleteEdgeRes = null; - if (result == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to replace edge with label {} to label {} from {} to {}. ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId); - - deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE); - if (deleteEdgeRes.isRight()) { - TitanOperationStatus titanStatus = deleteEdgeRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge with label {} from {} to {}. Status is {} ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId, titanStatus); - if (!titanStatus.equals(TitanOperationStatus.INVALID_ID)) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus); - } else { - result = StorageOperationStatus.INCONSISTENCY; - } - } - } - if (result == null) { - TitanOperationStatus createEdgeRes = titanDao.createEdge(ownerVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_STATE, deleteEdgeRes.left().value()); - if (createEdgeRes != TitanOperationStatus.OK) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes); - } - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private Either cloneToscaElementForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) { - - Either result = null; - Either cloneResult = null; - ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel()); - // check if component with the next version doesn't exist. - Iterator nextVersionComponentIter = toscaElementVertex.getVertex().edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); - if (nextVersionComponentIter != null && nextVersionComponentIter.hasNext()) { - Vertex nextVersionVertex = nextVersionComponentIter.next().inVertex(); - String fetchedVersion = (String) nextVersionVertex.property(GraphPropertyEnum.VERSION.getProperty()).value(); - String fetchedName = (String) nextVersionVertex.property(GraphPropertyEnum.NORMALIZED_NAME.getProperty()).value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to checkout component {} with version {}. The component with name {} and version {} was fetched from graph as existing following version. ", - toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME).toString(), toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION).toString(), fetchedName, fetchedVersion); - result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS); - } - if (result == null) { - toscaElementVertex.getOrSetDefaultInstantiationTypeForToscaElementJson(); - cloneResult = operation.cloneToscaElement(toscaElementVertex, cloneGraphVertexForCheckout(toscaElementVertex, modifierVertex), modifierVertex); - if (cloneResult.isRight()) { - result = Either.right(cloneResult.right().value()); - } - } - GraphVertex clonedVertex = null; - if (result == null) { - clonedVertex = cloneResult.left().value(); - TitanOperationStatus status = titanDao.createEdge(toscaElementVertex.getVertex(), cloneResult.left().value().getVertex(), EdgeLabelEnum.VERSION, new HashMap<>()); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION, - toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), cloneResult.left().value().getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - Boolean isHighest = (Boolean) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - GraphVertex prevVersionInCatalog = (isHighest != null && isHighest) ? null : toscaElementVertex; - StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRoot(clonedVertex, prevVersionInCatalog); - if (updateCatalogRes != StorageOperationStatus.OK) { - return Either.right(updateCatalogRes); - } - result = operation.getToscaElement(cloneResult.left().value().getUniqueId()); - if (result.isRight()) { - return result; - } - ToscaElement toscaElement = result.left().value(); - if (toscaElement.getToscaType() == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE) { - result = handleFixTopologyTemplate(toscaElementVertex, result, operation, clonedVertex, toscaElement); - } - } - - return result; - } - - private Either handleFixTopologyTemplate(GraphVertex toscaElementVertex, Either result, ToscaElementOperation operation, GraphVertex clonedVertex, - ToscaElement toscaElement) { - TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; - Map instInputs = topologyTemplate.getInstInputs(); - Map instGroups = topologyTemplate.getInstGroups(); - Map instArtifactsMap = topologyTemplate.getInstanceArtifacts(); - Map origCompMap = new HashMap<>(); - if (instInputs == null) { - instInputs = new HashMap<>(); - } - if (instGroups == null) { - instGroups = new HashMap<>(); - } - if (instArtifactsMap == null) { - instArtifactsMap = new HashMap<>(); - } - Map instancesMap = topologyTemplate.getComponentInstances(); - boolean isAddInstGroup = instGroups == null || instGroups.isEmpty(); - boolean needUpdateComposition = false; - - if (instancesMap != null && !instancesMap.isEmpty()) { - for (ComponentInstanceDataDefinition vfInst : instancesMap.values()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "vfInst name is {} . OriginType {}. ", vfInst.getName(), vfInst.getOriginType()); - if (vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) { - collectInstanceInputAndGroups(instInputs, instGroups, instArtifactsMap, origCompMap, isAddInstGroup, vfInst, clonedVertex); - } - needUpdateComposition = needUpdateComposition || fixToscaComponentName(vfInst, origCompMap); - if (needUpdateComposition) { - instancesMap.put(vfInst.getUniqueId(), vfInst); - } - } - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add to graph instInputs {} instGroups {} needUpdateComposition {}", instInputs, instGroups, needUpdateComposition); - if (!instInputs.isEmpty()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst inputs {} ", instInputs == null ? 0 : instInputs.size()); - GraphVertex toscaDataVertex = null; - Either instInpVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_INPUTS, JsonParseFlagEnum.ParseJson); - if (instInpVertexEither.isLeft()) { - toscaDataVertex = instInpVertexEither.left().value(); - } - - StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_INPUTS, EdgeLabelEnum.INST_INPUTS, toscaDataVertex, instInputs); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instance inputs . Status is {}. ", status); - result = Either.right(status); - return result; - } - - } - if (!instGroups.isEmpty()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst groups {} ", instGroups == null ? 0 : instGroups.size()); - GraphVertex toscaDataVertex = null; - Either instGrVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_GROUPS, JsonParseFlagEnum.ParseJson); - if (instGrVertexEither.isLeft()) { - toscaDataVertex = instGrVertexEither.left().value(); - } - - StorageOperationStatus status = handleToscaData(clonedVertex, VertexTypeEnum.INST_GROUPS, EdgeLabelEnum.INST_GROUPS, toscaDataVertex, instGroups); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instance group . Status is {}. ", status); - result = Either.right(status); - return result; - } - - } - if (needUpdateComposition) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before update Instances "); - Map jsonComposition = (Map) clonedVertex.getJson(); - CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - compositionDataDefinition.setComponentInstances(instancesMap); - Either updateElement = titanDao.updateVertex(clonedVertex); - if (updateElement.isRight()) { - TitanOperationStatus status = updateElement.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instances on metadata vertex . Status is {}. ", status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - } - - result = operation.getToscaElement(clonedVertex.getUniqueId()); - - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "RI map empty on component {}", toscaElement.getUniqueId()); - } - return result; - } - - // TODO remove after jsonModelMigration - public boolean resolveToscaComponentName(ComponentInstanceDataDefinition vfInst, Map origCompMap) { - return fixToscaComponentName(vfInst, origCompMap); - } - - private boolean fixToscaComponentName(ComponentInstanceDataDefinition vfInst, Map origCompMap) { - if (vfInst.getToscaComponentName() == null || vfInst.getToscaComponentName().isEmpty()) { - String ciUid = vfInst.getUniqueId(); - String origCompUid = vfInst.getComponentUid(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "fixToscaComponentName:: Ri id {} . origin component id is {}. type is{} ", ciUid, origCompUid, vfInst.getOriginType()); - ToscaElement origComp = null; - if (!origCompMap.containsKey(origCompUid)) { - Either origCompEither; - if (vfInst.getOriginType() == null || vfInst.getOriginType().name().equals(OriginTypeEnum.VF.name())) { - origCompEither = topologyTemplateOperation.getToscaElement(origCompUid); - } else { - origCompEither = nodeTypeOperation.getToscaElement(origCompUid); - } - if (origCompEither.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value()); - return false; - } - origComp = origCompEither.left().value(); - origCompMap.put(origCompUid, origComp); - } else { - origComp = origCompMap.get(origCompUid); - } - String toscaName = (String) origComp.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Origin component id is {}. toscaName {}", origCompUid, toscaName); - vfInst.setToscaComponentName(toscaName); - return true; - } - return false; - } - - private void collectInstanceInputAndGroups(Map instInputs, Map instGroups, Map instArtifactsMap, Map origCompMap, - boolean isAddInstGroup, ComponentInstanceDataDefinition vfInst, GraphVertex clonedVertex) { - String ciUid = vfInst.getUniqueId(); - String origCompUid = vfInst.getComponentUid(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "collectInstanceInputAndGroups:: Ri id {} . origin component id is {}. ", ciUid, origCompUid); - TopologyTemplate origComp = null; - if (!origCompMap.containsKey(origCompUid)) { - Either origCompEither = topologyTemplateOperation.getToscaElement(origCompUid); - if (origCompEither.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find orig component {} . Status is {}. ", origCompEither.right().value()); - return; - } - origComp = (TopologyTemplate) origCompEither.left().value(); - origCompMap.put(origCompUid, origComp); - } else { - origComp = (TopologyTemplate) origCompMap.get(origCompUid); - } - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Orig component {}. ", origComp.getUniqueId()); - - Map origInputs = origComp.getInputs(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Orig component inputs size {}. ", origInputs == null ? 0 : origInputs.size()); - if (origInputs != null) { - if (!instInputs.containsKey(ciUid)) { - MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(origInputs); - instInputs.put(ciUid, instProperties); - } else { - - MapPropertiesDataDefinition instInputMap = instInputs.get(ciUid); - Map instProp = instInputMap.getMapToscaDataDefinition(); - origInputs.forEach((propName, propMap) -> { - if (!instProp.containsKey(propName)) { - instProp.put(propName, propMap); - } - }); - } - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "ComponentInstanseInputs {}. ", instInputs.get(ciUid)); - } - - if (isAddInstGroup) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before create group instance. "); - List filteredGroups = null; - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups before filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); - if (origComp.getGroups() != null && !origComp.getGroups().isEmpty()) { - filteredGroups = origComp.getGroups().values().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList()); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups . Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); - } - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check vf groups after filter. Size is {} ", filteredGroups == null ? 0 : filteredGroups.size()); - if (CollectionUtils.isNotEmpty(filteredGroups)) { - MapArtifactDataDefinition instArifacts = null; - if (!instArtifactsMap.containsKey(ciUid)) { - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "istance artifacts not found "); - - Map deploymentArtifacts = origComp.getDeploymentArtifacts(); - - instArifacts = new MapArtifactDataDefinition(deploymentArtifacts); - addToscaDataDeepElementsBlockToToscaElement(clonedVertex, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, instArifacts, ciUid); - - instArtifactsMap.put(ciUid, instArifacts); - - } else { - instArifacts = instArtifactsMap.get(ciUid); - } - - if (instArifacts != null) { - Map instDeplArtifMap = instArifacts.getMapToscaDataDefinition(); - - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "check group dep artifacts. Size is {} ", instDeplArtifMap == null ? 0 : instDeplArtifMap.values().size()); - Map groupInstanceToCreate = new HashMap<>(); - for (GroupDataDefinition group : filteredGroups) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "create new groupInstance {} ", group.getName()); - GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition(group, vfInst, instDeplArtifMap); - List artifactsUid = new ArrayList<>(); - List artifactsId = new ArrayList<>(); - if (instDeplArtifMap!=null) { - for (ArtifactDataDefinition artifact : instDeplArtifMap.values()) { - Optional op = group.getArtifacts().stream().filter(p -> p.equals(artifact.getGeneratedFromId())).findAny(); - if (op.isPresent()) { - artifactsUid.add(artifact.getArtifactUUID()); - artifactsId.add(artifact.getUniqueId()); - - } - } - } - groupInstance.setGroupInstanceArtifacts(artifactsId); - groupInstance.setGroupInstanceArtifactsUuid(artifactsUid); - groupInstanceToCreate.put(groupInstance.getName(), groupInstance); - } - if (MapUtils.isNotEmpty(groupInstanceToCreate)) { - instGroups.put(vfInst.getUniqueId(), new MapGroupsDataDefinition(groupInstanceToCreate)); - - } - } - } - } - } - - private GraphVertex cloneGraphVertexForCheckout(GraphVertex toscaElementVertex, GraphVertex modifierVertex) { - GraphVertex nextVersionToscaElementVertex = new GraphVertex(); - String uniqueId = UniqueIdBuilder.buildComponentUniqueId(); - Map metadataProperties = new HashMap<>(toscaElementVertex.getMetadataProperties()); - nextVersionToscaElementVertex.setMetadataProperties(metadataProperties); - nextVersionToscaElementVertex.setUniqueId(uniqueId); - nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel()); - nextVersionToscaElementVertex.setType(toscaElementVertex.getType()); - - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name()); - String nextVersion = getNextVersion((String) toscaElementVertex.getMetadataProperty(GraphPropertyEnum.VERSION)); - if (isFirstCheckoutAfterCertification(nextVersion)) { - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UUID, IdBuilderUtils.generateUUID()); - } - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, nextVersion); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name()); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) { - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name()); - } - if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) { - nextVersionToscaElementVertex.setMetadataJson(new HashMap<>(toscaElementVertex.getMetadataJson())); - nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties(); - } - long currTime = System.currentTimeMillis(); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, currTime); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, currTime); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId()); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId()); - if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE) { - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CONFORMANCE_LEVEL, ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel()); - } - - if (!MapUtils.isEmpty(toscaElementVertex.getJson())) { - nextVersionToscaElementVertex.setJson(new HashMap(toscaElementVertex.getJson())); - } - return nextVersionToscaElementVertex; - } - - private Either cloneToscaElementForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) { - Either result; - Either, StorageOperationStatus> deleteResult = null; - GraphVertex clonedToscaElement = null; - result = getToscaElementOperation(toscaElementVertex.getLabel()).cloneToscaElement(toscaElementVertex, cloneGraphVertexForCertify(toscaElementVertex, modifierVertex, majorVersion), modifierVertex); - if (result.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element {} for certification. Sattus is {}. ", toscaElementVertex.getUniqueId(), result.right().value()); - } else { - clonedToscaElement = result.left().value(); - StorageOperationStatus updateEdgeToCatalog = updateEdgeToCatalogRoot(clonedToscaElement, toscaElementVertex); - if (updateEdgeToCatalog != StorageOperationStatus.OK) { - return Either.right(updateEdgeToCatalog); - } - deleteResult = deleteAllPreviousNotCertifiedVersions(toscaElementVertex); - if (deleteResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete all previous npt certified versions of tosca element {}. Status is {}. ", toscaElementVertex.getUniqueId(), deleteResult.right().value()); - result = Either.right(deleteResult.right().value()); - } - } - if (result.isLeft()) { - result = handlePreviousVersionRelation(clonedToscaElement, deleteResult.left().value(), majorVersion); - } - return result; - } - - private Either handlePreviousVersionRelation(GraphVertex clonedToscaElement, List deletedVersions, Integer majorVersion) { - Either result = null; - Vertex previousCertifiedToscaElement = null; - if (majorVersion > 0) { - List firstMinorVersionVertex = deletedVersions.stream().filter(gv -> getMinorVersion((String) gv.getMetadataProperty(GraphPropertyEnum.VERSION)) == 1).collect(Collectors.toList()); - - if (CollectionUtils.isEmpty(firstMinorVersionVertex)) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } else { - previousCertifiedToscaElement = getPreviousCertifiedToscaElement(firstMinorVersionVertex.get(0)); - if (previousCertifiedToscaElement == null) { - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - if (result == null) { - TitanOperationStatus status = titanDao.createEdge(previousCertifiedToscaElement, clonedToscaElement.getVertex(), EdgeLabelEnum.VERSION, new HashMap<>()); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION, - previousCertifiedToscaElement.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), clonedToscaElement.getUniqueId(), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - - } - if (result == null) { - result = Either.left(clonedToscaElement); - } - return result; - } - - private Vertex getPreviousCertifiedToscaElement(GraphVertex graphVertex) { - - Iterator edges = graphVertex.getVertex().edges(Direction.IN, EdgeLabelEnum.VERSION.name()); - if (edges.hasNext()) { - return edges.next().outVertex(); - } - return null; - } - - private Either, StorageOperationStatus> deleteAllPreviousNotCertifiedVersions(GraphVertex toscaElementVertex) { - Either, StorageOperationStatus> result = null; - - ToscaElementOperation operation = getToscaElementOperation(toscaElementVertex.getLabel()); - List previosVersions = null; - Object uuid = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.UUID); - Object componentName = toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NAME); - try { - Map properties = new HashMap<>(); - properties.put(GraphPropertyEnum.UUID, uuid); - properties.put(GraphPropertyEnum.NAME, componentName); - Either, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(toscaElementVertex.getLabel(), properties, JsonParseFlagEnum.ParseMetadata); - if (getToscaElementsRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value())); - } - if (result == null) { - previosVersions = getToscaElementsRes.left().value(); - Either deleteResult = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value()); - if (deleteResult.isRight()) { - result = Either.right(deleteResult.right().value()); - } - } - if (result == null) { - result = Either.left(previosVersions); - } - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during deleteng all tosca elements by UUID {} and name {}. {} ", uuid, componentName, e.getMessage()); - } - return result; - } - - private GraphVertex cloneGraphVertexForCertify(GraphVertex toscaElementVertex, GraphVertex modifierVertex, Integer majorVersion) { - - GraphVertex nextVersionToscaElementVertex = new GraphVertex(); - String uniqueId = IdBuilderUtils.generateUniqueId(); - Map metadataProperties = new EnumMap<>(toscaElementVertex.getMetadataProperties()); - nextVersionToscaElementVertex.setMetadataProperties(metadataProperties); - nextVersionToscaElementVertex.setUniqueId(uniqueId); - nextVersionToscaElementVertex.setLabel(toscaElementVertex.getLabel()); - nextVersionToscaElementVertex.setType(toscaElementVertex.getType()); - - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uniqueId); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, nextVersionToscaElementVertex.getType().name()); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.VERSION, (majorVersion + 1) + VERSION_DELIMITER + "0"); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.CREATION_DATE, System.currentTimeMillis()); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, null); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_CREATOR, modifierVertex.getUniqueId()); - nextVersionToscaElementVertex.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifierVertex.getUniqueId()); - - if (toscaElementVertex.getType() == ComponentTypeEnum.SERVICE && toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED)) { - nextVersionToscaElementVertex.addMetadataProperty(GraphPropertyEnum.DISTRIBUTION_STATUS, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name()); - } - if (!MapUtils.isEmpty(toscaElementVertex.getMetadataJson())) { - nextVersionToscaElementVertex.setMetadataJson(new HashMap<>(toscaElementVertex.getMetadataJson())); - nextVersionToscaElementVertex.updateMetadataJsonWithCurrentMetadataProperties(); - } - if (!MapUtils.isEmpty(toscaElementVertex.getJson())) { - nextVersionToscaElementVertex.setJson(new HashMap(toscaElementVertex.getJson())); - } - return nextVersionToscaElementVertex; - } - - - private Either checkinToscaELement(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex, LifecycleStateEnum nextState) { - Either updateRelationsRes; - Either result = changeStateToCheckedIn(currState, toscaElementVertex, ownerVertex, modifierVertex); - if (result.isLeft()) { - toscaElementVertex.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name()); - toscaElementVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - result = updateToscaElementVertexMetadataPropertiesAndJson(toscaElementVertex); - } - if (result.isLeft()) { - updateRelationsRes = updateLastModifierEdge(toscaElementVertex, ownerVertex, modifierVertex); - if (updateRelationsRes.isRight()) { - result = Either.right(updateRelationsRes.right().value()); - } - } - return result; - } - - private Either updateToscaElementVertexMetadataPropertiesAndJson(GraphVertex toscaElementVertex) { - - Either result; - - Either updateVertexRes = titanDao.updateVertex(toscaElementVertex); - if (updateVertexRes.isRight()) { - TitanOperationStatus titatStatus = updateVertexRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update state of tosca element vertex {} metadata. Status is {}", toscaElementVertex.getUniqueId(), titatStatus); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus)); - } else { - result = Either.left(updateVertexRes.left().value()); - } - return result; - } - - private Either changeStateToCheckedIn(LifecycleStateEnum currState, GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) { - Either result = null; - LifecycleStateEnum nextState = LifecycleStateEnum.NOT_CERTIFIED_CHECKIN; - String faileToUpdateStateMsg = "Failed to update state of tosca element {}. Status is {}"; - - if (currState == LifecycleStateEnum.READY_FOR_CERTIFICATION) { - // In case of cancel "ready for certification" remove last state edge with "STATE" property equals to "NOT_CERTIFIED_CHECKIN" - Map vertexProperties = new EnumMap<>(GraphPropertyEnum.class); - vertexProperties.put(GraphPropertyEnum.STATE, nextState); - Either deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElementVertex, EdgeLabelEnum.LAST_STATE, vertexProperties); - if (deleteResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId(), deleteResult.right().value()); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to update last state relation"); - result = Either.right(StorageOperationStatus.INCONSISTENCY); - } - } - if (result == null) { - // Remove CHECKOUT relation - Either deleteEdgeResult = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE); - if (deleteEdgeResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeResult.right().value())); - } - } - if (result == null) { - // Create CHECKIN relation - Map edgeProperties = new EnumMap<>(EdgePropertyEnum.class); - edgeProperties.put(EdgePropertyEnum.STATE, nextState); - TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.STATE, edgeProperties); - if (createEdgeRes != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes)); - } - } - if (result == null) { - result = Either.left(toscaElementVertex); - } - return result; - } - - private Either updateLastModifierEdge(GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) { - Either result = null; - if (!modifierVertex.getMetadataProperties().get(GraphPropertyEnum.USERID).equals(ownerVertex.getMetadataProperties().get(GraphPropertyEnum.USERID))) { - Either deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.LAST_MODIFIER); - if (deleteEdgeRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete last modifier {} to tosca element {}. Edge type is {}", ownerVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeRes.right().value())); - } - if (result == null) { - TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); - - if (createEdgeRes != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to associate user {} to component {}. Edge type is {}", modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes)); - } else { - result = Either.left(modifierVertex); - } - } - } else { - result = Either.left(ownerVertex); - } - return result; - } - - private Map> prepareParametersToGetVerticesForCheckin(String toscaElementId, String modifierId, String ownerId) { - Map> verticesToGetParameters = new HashMap<>(); - verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseMetadata)); - verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); - verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); - return verticesToGetParameters; - } - - private Map> prepareParametersToGetVerticesForRequestCertification(String toscaElementId, String modifierId, String ownerId) { - Map> verticesToGetParameters = new HashMap<>(); - verticesToGetParameters.put(toscaElementId, new ImmutablePair<>(GraphPropertyEnum.UNIQUE_ID, JsonParseFlagEnum.ParseAll)); - verticesToGetParameters.put(modifierId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); - verticesToGetParameters.put(ownerId, new ImmutablePair<>(GraphPropertyEnum.USERID, JsonParseFlagEnum.NoParse)); - return verticesToGetParameters; - } - - private Map> prepareParametersToGetVerticesForCheckout(String toscaElementId, String modifierId, String ownerId) { - //Implementation is currently identical - return prepareParametersToGetVerticesForRequestCertification(toscaElementId,modifierId, ownerId); - } - - private String getNextCertifiedVersion(String version) { - String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); - Integer nextMajorVersion = Integer.parseInt(versionParts[0]) + 1; - return nextMajorVersion + VERSION_DELIMITER + "0"; - } - - private String getNextVersion(String currVersion) { - String[] versionParts = currVersion.split(VERSION_DELIMITER_REGEXP); - Integer minorVersion = Integer.parseInt(versionParts[1]) + 1; - return versionParts[0] + VERSION_DELIMITER + minorVersion; - } - - private Integer getMinorVersion(String version) { - String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); - return Integer.parseInt(versionParts[1]); - } - - private Integer getMajorVersion(String version) { - String[] versionParts = version.split(VERSION_DELIMITER_REGEXP); - return Integer.parseInt(versionParts[0]); - } - - private boolean isFirstCheckoutAfterCertification(String version) { - return (Integer.parseInt(version.split(VERSION_DELIMITER_REGEXP)[0]) != 0 && Integer.parseInt(version.split(VERSION_DELIMITER_REGEXP)[1]) == 1); - } - - public Either forceCerificationOfToscaElement(String toscaElementId, String modifierId, String ownerId, String currVersion) { - Either resultUpdate = null; - Either result = null; - GraphVertex toscaElement = null; - GraphVertex modifier = null; - GraphVertex owner; - try { - Either, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId)); - if (getVerticesRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value())); - } - if (result == null) { - toscaElement = getVerticesRes.left().value().get(toscaElementId); - modifier = getVerticesRes.left().value().get(modifierId); - owner = getVerticesRes.left().value().get(ownerId); - - StorageOperationStatus status = handleRelationsUponForceCertification(toscaElement, modifier, owner); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to handle relations on certification request for tosca element {}. Status is {}. ", toscaElement.getUniqueId(), status); - } - } - if (result == null) { - LifecycleStateEnum nextState = LifecycleStateEnum.CERTIFIED; - - toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - toscaElement.addMetadataProperty(GraphPropertyEnum.VERSION, getNextCertifiedVersion(currVersion)); - - resultUpdate = updateToscaElementVertexMetadataPropertiesAndJson(toscaElement); - if (resultUpdate.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set lifecycle for tosca elememt {} to state {}, error: {}", toscaElement.getUniqueId(), nextState, resultUpdate.right().value()); - result = Either.right(resultUpdate.right().value()); - } - } - if (result == null) { - ToscaElementOperation operation = getToscaElementOperation(toscaElement.getLabel()); - result = operation.getToscaElement(toscaElement.getUniqueId()); - } - return result; - - } catch (Exception e) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during request certification tosca element {}. {}", toscaElementId, e.getMessage()); - } - return result; - } - - private StorageOperationStatus handleRelationsUponForceCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) { - - StorageOperationStatus result = null; - TitanOperationStatus status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE); - if (status != TitanOperationStatus.OK) { - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (result == null) { - Map properties = new EnumMap<>(EdgePropertyEnum.class); - properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFIED); - status = titanDao.createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - } - if (result == null) { - result = StorageOperationStatus.OK; - } - return result; - } - - private StorageOperationStatus updateEdgeToCatalogRootByUndoCheckout(TitanVertex preV, GraphVertex curV) { - if (preV == null) { - return updateEdgeToCatalogRoot(null, curV); - } - String uniqueIdPreVer = (String) titanDao.getProperty((TitanVertex) preV, GraphPropertyEnum.UNIQUE_ID.getProperty()); - LifecycleStateEnum state = LifecycleStateEnum.findState((String) titanDao.getProperty(preV, GraphPropertyEnum.STATE.getProperty())); - if (state == LifecycleStateEnum.CERTIFIED) { - return updateEdgeToCatalogRoot(null, curV); - } - return titanDao.getVertexById(uniqueIdPreVer) - .either(l -> updateEdgeToCatalogRoot(l, curV), - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - private StorageOperationStatus updateEdgeToCatalogRoot(GraphVertex newVersionV, GraphVertex prevVersionV) { - Either catalog = titanDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT); - if (catalog.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch catalog vertex. error {}", catalog.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(catalog.right().value()); - } - GraphVertex catalogV = catalog.left().value(); - if (newVersionV != null) { - Boolean isAbstract = (Boolean) newVersionV.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); - - if ( isAbstract == null || !isAbstract ) { - // no new vertex, only delete previous - TitanOperationStatus result = titanDao.createEdge(catalogV, newVersionV, EdgeLabelEnum.CATALOG_ELEMENT, null); - if (result != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge from {} to catalog vertex. error {}", newVersionV.getUniqueId(), result); - return DaoStatusConverter.convertTitanStatusToStorageStatus(result); - } - } - } - if (prevVersionV != null) { - Boolean isAbstract = (Boolean) prevVersionV.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); - if (isAbstract == null || !isAbstract) { - // if prev == null -> new resource was added - Either deleteResult = titanDao.deleteEdge(catalogV, prevVersionV, EdgeLabelEnum.CATALOG_ELEMENT); - if (deleteResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge from {} to catalog vertex. error {}", prevVersionV.getUniqueId(), deleteResult.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(deleteResult.right().value()); - } - } - } - return StorageOperationStatus.OK; - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperation.java deleted file mode 100644 index f700c2eb69..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperation.java +++ /dev/null @@ -1,1360 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.google.gson.Gson; -import com.google.gson.reflect.TypeToken; -import fj.data.Either; -import org.apache.commons.collections.CollectionUtils; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.apache.tinkerpop.gremlin.structure.VertexProperty; -import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; -import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.catalog.CatalogComponent; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -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.UniqueIdBuilder; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.util.StopWatch; - -import java.lang.reflect.Type; -import java.util.*; -import java.util.Map.Entry; -import java.util.stream.Collectors; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Set; - -public abstract class ToscaElementOperation extends BaseOperation { - private static final String FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR = "failed to fetch {} for tosca element with id {}, error {}"; - - private static final String CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS = "Cannot find user {} in the graph. status is {}"; - - private static final String FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS = "Failed to create edge with label {} from user vertex {} to tosca element vertex {} on graph. Status is {}. "; - - private static Logger log = Logger.getLogger(ToscaElementOperation.class.getName()); - - private static final Gson gson = new Gson(); - - @Autowired - protected CategoryOperation categoryOperation; - - protected Gson getGson() { - return gson; - } - - - protected Either getComponentByLabelAndId(String uniqueId, ToscaElementTypeEnum nodeType, JsonParseFlagEnum parseFlag) { - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.UNIQUE_ID, uniqueId); - - VertexTypeEnum vertexType = ToscaElementTypeEnum.getVertexTypeByToscaType(nodeType); - Either, TitanOperationStatus> getResponse = titanDao.getByCriteria(vertexType, propertiesToMatch, parseFlag); - if (getResponse.isRight()) { - log.debug("Couldn't fetch component with type {} and unique id {}, error: {}", vertexType, uniqueId, getResponse.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getResponse.right().value())); - - } - List componentList = getResponse.left().value(); - if (componentList.isEmpty()) { - log.debug("Component with type {} and unique id {} was not found", vertexType, uniqueId); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - GraphVertex vertexG = componentList.get(0); - return Either.left(vertexG); - } - - public Either getToscaElement(String uniqueId) { - return getToscaElement(uniqueId, new ComponentParametersView()); - } - - public Either markComponentToDelete(GraphVertex componentToDelete) { - Either result = null; - - Boolean isDeleted = (Boolean) componentToDelete.getMetadataProperty(GraphPropertyEnum.IS_DELETED); - if (isDeleted != null && isDeleted && !(Boolean) componentToDelete.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION)) { - // component already marked for delete - result = Either.left(componentToDelete); - return result; - } else { - - componentToDelete.addMetadataProperty(GraphPropertyEnum.IS_DELETED, Boolean.TRUE); - componentToDelete.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); - - Either updateNode = titanDao.updateVertex(componentToDelete); - - StorageOperationStatus updateComponent; - if (updateNode.isRight()) { - log.debug("Failed to update component {}. status is {}", componentToDelete.getUniqueId(), updateNode.right().value()); - updateComponent = DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value()); - result = Either.right(updateComponent); - return result; - } - - result = Either.left(componentToDelete); - return result; - } - } - - /** - * Performs a shadow clone of previousToscaElement - * - * @param previousToscaElement - * @param nextToscaElement - * @param user - * @return - */ - public Either cloneToscaElement(GraphVertex previousToscaElement, GraphVertex nextToscaElement, GraphVertex user) { - - Either result = null; - GraphVertex createdToscaElementVertex = null; - TitanOperationStatus status; - - Either createNextVersionRes = titanDao.createVertex(nextToscaElement); - if (createNextVersionRes.isRight()) { - status = createNextVersionRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create tosca element vertex {} with version {} on graph. Status is {}. ", previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), - previousToscaElement.getMetadataProperty(GraphPropertyEnum.VERSION), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - createdToscaElementVertex = createNextVersionRes.left().value(); - Map properties = new HashMap<>(); - properties.put(EdgePropertyEnum.STATE, createdToscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE)); - status = titanDao.createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.STATE, properties); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.STATE, user.getUniqueId(), - previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - status = titanDao.createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>()); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.LAST_MODIFIER, user.getUniqueId(), - nextToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - status = titanDao.createEdge(user.getVertex(), createdToscaElementVertex.getVertex(), EdgeLabelEnum.CREATOR, new HashMap<>()); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_CREATE_EDGE_WITH_LABEL_FROM_USER_VERTEX_TO_TOSCA_ELEMENT_VERTEX_ON_GRAPH_STATUS_IS, EdgeLabelEnum.CREATOR, user.getUniqueId(), - nextToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (result == null) { - Iterator edgesToCopyIter = previousToscaElement.getVertex().edges(Direction.OUT); - while (edgesToCopyIter.hasNext()) { - Edge currEdge = edgesToCopyIter.next(); - Vertex currVertex = currEdge.inVertex(); - status = titanDao.createEdge(createdToscaElementVertex.getVertex(), currVertex, EdgeLabelEnum.getEdgeLabelEnum(currEdge.label()), currEdge); - if (status != TitanOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from tosca element vertex {} to vertex with label {} on graph. Status is {}. ", currEdge.label(), createdToscaElementVertex.getUniqueId(), - currVertex.property(GraphPropertyEnum.LABEL.getProperty()), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - break; - } - } - } - - if (result == null) { - result = Either.left(createdToscaElementVertex); - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to clone tosca element {} with the name {}. ", previousToscaElement.getUniqueId(), previousToscaElement.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME)); - } - return result; - } - - protected TitanOperationStatus setLastModifierFromGraph(GraphVertex componentV, ToscaElement toscaElement) { - Either parentVertex = titanDao.getParentVertex(componentV, EdgeLabelEnum.LAST_MODIFIER, JsonParseFlagEnum.NoParse); - if (parentVertex.isRight()) { - log.debug("Failed to fetch last modifier for tosca element with id {} error {}", componentV.getUniqueId(), parentVertex.right().value()); - return parentVertex.right().value(); - } - GraphVertex userV = parentVertex.left().value(); - String userId = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); - toscaElement.setLastUpdaterUserId(userId); - toscaElement.setLastUpdaterFullName(buildFullName(userV)); - return TitanOperationStatus.OK; - } - - public String buildFullName(GraphVertex userV) { - - String fullName = (String) userV.getMetadataProperty(GraphPropertyEnum.FIRST_NAME); - if (fullName == null) { - fullName = ""; - } else { - fullName = fullName + " "; - } - String lastName = (String) userV.getMetadataProperty(GraphPropertyEnum.LAST_NAME); - if (lastName != null) { - fullName += lastName; - } - return fullName; - } - - protected TitanOperationStatus setCreatorFromGraph(GraphVertex componentV, ToscaElement toscaElement) { - Either parentVertex = titanDao.getParentVertex(componentV, EdgeLabelEnum.CREATOR, JsonParseFlagEnum.NoParse); - if (parentVertex.isRight()) { - log.debug("Failed to fetch creator for tosca element with id {} error {}", componentV.getUniqueId(), parentVertex.right().value()); - return parentVertex.right().value(); - } - GraphVertex userV = parentVertex.left().value(); - String creatorUserId = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); - toscaElement.setCreatorUserId(creatorUserId); - toscaElement.setCreatorFullName(buildFullName(userV)); - - return TitanOperationStatus.OK; - } - - protected T getResourceMetaDataFromResource(T toscaElement) { - if (toscaElement.getNormalizedName() == null || toscaElement.getNormalizedName().isEmpty()) { - toscaElement.setNormalizedName(ValidationUtils.normaliseComponentName(toscaElement.getName())); - } - if (toscaElement.getSystemName() == null || toscaElement.getSystemName().isEmpty()) { - toscaElement.setSystemName(ValidationUtils.convertToSystemName(toscaElement.getName())); - } - - LifecycleStateEnum lifecycleStateEnum = toscaElement.getLifecycleState(); - if (lifecycleStateEnum == null) { - toscaElement.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - } - long currentDate = System.currentTimeMillis(); - if (toscaElement.getCreationDate() == null) { - toscaElement.setCreationDate(currentDate); - } - toscaElement.setLastUpdateDate(currentDate); - - return toscaElement; - } - - protected void fillCommonMetadata(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { - if (toscaElement.isHighestVersion() == null) { - toscaElement.setHighestVersion(true); - } - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_DELETED, toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, toscaElement.getMetadataValueOrDefault(JsonPresentationFields.HIGHEST_VERSION, Boolean.TRUE)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.STATE, toscaElement.getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.RESOURCE_TYPE, toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_TYPE)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.VERSION, toscaElement.getMetadataValue(JsonPresentationFields.VERSION)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME, toscaElement.getMetadataValue(JsonPresentationFields.NORMALIZED_NAME)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, toscaElement.getMetadataValue(JsonPresentationFields.UNIQUE_ID)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.UUID, toscaElement.getMetadataValue(JsonPresentationFields.UUID)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_ABSTRACT, toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.INVARIANT_UUID, toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.NAME, toscaElement.getMetadataValue(JsonPresentationFields.NAME)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.SYSTEM_NAME, toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_ARCHIVED, toscaElement.getMetadataValue(JsonPresentationFields.IS_ARCHIVED)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME, toscaElement.getMetadataValue(JsonPresentationFields.ARCHIVE_TIME)); - nodeTypeVertex.addMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED, toscaElement.getMetadataValue(JsonPresentationFields.IS_VSP_ARCHIVED)); - toscaElement.getMetadata().entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> nodeTypeVertex.setJsonMetadataField(JsonPresentationFields.getByPresentation(e.getKey()), e.getValue())); - - nodeTypeVertex.setUniqueId(toscaElement.getUniqueId()); - nodeTypeVertex.setType(toscaElement.getComponentType()); - - } - - protected StorageOperationStatus assosiateToUsers(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { - // handle user - String userId = toscaElement.getCreatorUserId(); - - Either findUser = findUserVertex(userId); - - if (findUser.isRight()) { - TitanOperationStatus status = findUser.right().value(); - log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, userId, status); - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); - - } - GraphVertex creatorVertex = findUser.left().value(); - GraphVertex updaterVertex = creatorVertex; - String updaterId = toscaElement.getLastUpdaterUserId(); - if (updaterId != null && !updaterId.equals(userId)) { - findUser = findUserVertex(updaterId); - if (findUser.isRight()) { - TitanOperationStatus status = findUser.right().value(); - log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, userId, status); - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } else { - updaterVertex = findUser.left().value(); - } - } - Map props = new EnumMap<>(EdgePropertyEnum.class); - props.put(EdgePropertyEnum.STATE, (String) toscaElement.getMetadataValue(JsonPresentationFields.LIFECYCLE_STATE)); - - TitanOperationStatus result = titanDao.createEdge(updaterVertex, nodeTypeVertex, EdgeLabelEnum.STATE, props); - log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.STATE); - if (TitanOperationStatus.OK != result) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(result); - } - result = titanDao.createEdge(updaterVertex, nodeTypeVertex, EdgeLabelEnum.LAST_MODIFIER, null); - log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); - if (!result.equals(TitanOperationStatus.OK)) { - log.error("Failed to associate user {} to resource {}. Edge type is {}", updaterVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER); - return DaoStatusConverter.convertTitanStatusToStorageStatus(result); - } - - toscaElement.setLastUpdaterUserId(toscaElement.getCreatorUserId()); - toscaElement.setLastUpdaterFullName(toscaElement.getCreatorFullName()); - - result = titanDao.createEdge(creatorVertex, nodeTypeVertex, EdgeLabelEnum.CREATOR, null); - log.debug("After associating user {} to resource {}. Edge type is {} ", creatorVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.CREATOR); - if (!result.equals(TitanOperationStatus.OK)) { - log.error("Failed to associate user {} to resource {}. Edge type is {} ", creatorVertex, nodeTypeVertex.getUniqueId(), EdgeLabelEnum.CREATOR); - return DaoStatusConverter.convertTitanStatusToStorageStatus(result); - } - return StorageOperationStatus.OK; - } - - protected StorageOperationStatus assosiateResourceMetadataToCategory(GraphVertex nodeTypeVertex, ToscaElement nodeType) { - String subcategoryName = nodeType.getCategories().get(0).getSubcategories().get(0).getName(); - String categoryName = nodeType.getCategories().get(0).getName(); - Either getCategoryVertex = getResourceCategoryVertex(nodeType.getUniqueId(), subcategoryName, categoryName); - - if (getCategoryVertex.isRight()) { - return getCategoryVertex.right().value(); - } - - GraphVertex subCategoryV = getCategoryVertex.left().value(); - - TitanOperationStatus createEdge = titanDao.createEdge(nodeTypeVertex, subCategoryV, EdgeLabelEnum.CATEGORY, new HashMap<>()); - if (createEdge != TitanOperationStatus.OK) { - log.trace("Failed to associate resource {} to category {} with id {}", nodeType.getUniqueId(), subcategoryName, subCategoryV.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(createEdge); - } - return StorageOperationStatus.OK; - } - - protected Either getResourceCategoryVertex(String elementId, String subcategoryName, String categoryName) { - Either category = categoryOperation.getCategory(categoryName, VertexTypeEnum.RESOURCE_CATEGORY); - if (category.isRight()) { - log.trace("Failed to fetch category {} for resource {} error {}", categoryName, elementId, category.right().value()); - return Either.right(category.right().value()); - } - GraphVertex categoryV = category.left().value(); - - if (subcategoryName != null) { - Either subCategory = categoryOperation.getSubCategoryForCategory(categoryV, subcategoryName); - if (subCategory.isRight()) { - log.trace("Failed to fetch subcategory {} of category for resource {} error {}", subcategoryName, categoryName, elementId, subCategory.right().value()); - return Either.right(subCategory.right().value()); - } - - GraphVertex subCategoryV = subCategory.left().value(); - return Either.left(subCategoryV); - } - return Either.left(categoryV); - } - - private StorageOperationStatus associateArtifactsToResource(GraphVertex nodeTypeVertex, ToscaElement toscaElement) { - Map artifacts = toscaElement.getArtifacts(); - Either status; - if (artifacts != null) { - artifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { - String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); - a.setUniqueId(uniqueId); - }); - status = associateElementToData(nodeTypeVertex, VertexTypeEnum.ARTIFACTS, EdgeLabelEnum.ARTIFACTS, artifacts); - if (status.isRight()) { - return status.right().value(); - } - } - Map toscaArtifacts = toscaElement.getToscaArtifacts(); - if (toscaArtifacts != null) { - toscaArtifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { - String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); - a.setUniqueId(uniqueId); - }); - status = associateElementToData(nodeTypeVertex, VertexTypeEnum.TOSCA_ARTIFACTS, EdgeLabelEnum.TOSCA_ARTIFACTS, toscaArtifacts); - if (status.isRight()) { - return status.right().value(); - } - } - Map deploymentArtifacts = toscaElement.getDeploymentArtifacts(); - if (deploymentArtifacts != null) { - deploymentArtifacts.values().stream().filter(a -> a.getUniqueId() == null).forEach(a -> { - String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId().toLowerCase(), a.getArtifactLabel().toLowerCase()); - a.setUniqueId(uniqueId); - }); - status = associateElementToData(nodeTypeVertex, VertexTypeEnum.DEPLOYMENT_ARTIFACTS, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS, deploymentArtifacts); - if (status.isRight()) { - return status.right().value(); - } - } - return StorageOperationStatus.OK; - } - - protected TitanOperationStatus disassociateAndDeleteCommonElements(GraphVertex toscaElementVertex) { - TitanOperationStatus status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate artifact for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.TOSCA_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate tosca artifact for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to deployment artifact for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.PROPERTIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate properties for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ATTRIBUTES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate attributes for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate additional information for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate capabilities for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.REQUIREMENTS); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - status = titanDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.FORWARDING_PATH); - if (status != TitanOperationStatus.OK) { - log.debug("Failed to disaccociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status); - return status; - } - return TitanOperationStatus.OK; - } - - protected StorageOperationStatus assosiateCommonForToscaElement(GraphVertex nodeTypeVertex, ToscaElement toscaElement, List derivedResources) { - - StorageOperationStatus associateUsers = assosiateToUsers(nodeTypeVertex, toscaElement); - if (associateUsers != StorageOperationStatus.OK) { - return associateUsers; - } - StorageOperationStatus associateArtifacts = associateArtifactsToResource(nodeTypeVertex, toscaElement); - if (associateArtifacts != StorageOperationStatus.OK) { - return associateArtifacts; - } - StorageOperationStatus associateProperties = associatePropertiesToResource(nodeTypeVertex, toscaElement, derivedResources); - if (associateProperties != StorageOperationStatus.OK) { - return associateProperties; - } - StorageOperationStatus associateAdditionaInfo = associateAdditionalInfoToResource(nodeTypeVertex, toscaElement); - if (associateAdditionaInfo != StorageOperationStatus.OK) { - return associateAdditionaInfo; - } - if (needConnectToCatalog(toscaElement)) { - StorageOperationStatus associateToCatalog = associateToCatalogRoot(nodeTypeVertex); - if (associateToCatalog != StorageOperationStatus.OK) { - return associateToCatalog; - } - } - return StorageOperationStatus.OK; - } - - private boolean needConnectToCatalog(ToscaElement toscaElement) { - Boolean isAbstract = (Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT); - if (isAbstract != null && isAbstract) { - return false; - } - return toscaElement.isHighestVersion(); - } - - private StorageOperationStatus associateToCatalogRoot(GraphVertex nodeTypeVertex) { - Either catalog = titanDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT); - if (catalog.isRight()) { - log.debug("Failed to fetch catalog vertex. error {}", catalog.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(catalog.right().value()); - } - TitanOperationStatus createEdge = titanDao.createEdge(catalog.left().value(), nodeTypeVertex, EdgeLabelEnum.CATALOG_ELEMENT, null); - - return DaoStatusConverter.convertTitanStatusToStorageStatus(createEdge); - } - - protected StorageOperationStatus associatePropertiesToResource(GraphVertex nodeTypeVertex, ToscaElement nodeType, List derivedResources) { - // Note : currently only one derived supported!!!! - Either, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.PROPERTIES); - if (dataFromDerived.isRight()) { - return dataFromDerived.right().value(); - } - Map propertiesAll = dataFromDerived.left().value(); - - Map properties = nodeType.getProperties(); - - if (properties != null) { - properties.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> { - String uid = UniqueIdBuilder.buildPropertyUniqueId(nodeTypeVertex.getUniqueId(), p.getName()); - p.setUniqueId(uid); - }); - - Either, String> eitherMerged = ToscaDataDefinition.mergeDataMaps(propertiesAll, properties); - if (eitherMerged.isRight()) { - // TODO re-factor error handling - moving BL to operation resulted in loss of info about the invalid property - log.debug("property {} cannot be overriden", eitherMerged.right().value()); - return StorageOperationStatus.INVALID_PROPERTY; - } - } - if (!propertiesAll.isEmpty()) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.PROPERTIES, EdgeLabelEnum.PROPERTIES, propertiesAll); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus associateAdditionalInfoToResource(GraphVertex nodeTypeVertex, ToscaElement nodeType) { - Map additionalInformation = nodeType.getAdditionalInformation(); - if (additionalInformation != null) { - Either assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, additionalInformation); - if (assosiateElementToData.isRight()) { - return assosiateElementToData.right().value(); - } - } - return StorageOperationStatus.OK; - } - - protected Either, StorageOperationStatus> getDataFromDerived(List derivedResources, EdgeLabelEnum edge) { - Map propertiesAll = new HashMap<>(); - - if (derivedResources != null && !derivedResources.isEmpty()) { - for (GraphVertex derived : derivedResources) { - Either, TitanOperationStatus> derivedProperties = titanDao.getChildrenVertecies(derived, edge, JsonParseFlagEnum.ParseJson); - if (derivedProperties.isRight()) { - if (derivedProperties.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("Failed to get properties for derived from {} error {}", derived.getUniqueId(), derivedProperties.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(derivedProperties.right().value())); - } else { - continue; - } - } - List propList = derivedProperties.left().value(); - for (GraphVertex propV : propList) { - Map propertiesFromDerived = (Map) propV.getJson(); - if (propertiesFromDerived != null) { - propertiesFromDerived.entrySet().forEach(x -> x.getValue().setOwnerIdIfEmpty(derived.getUniqueId())); - propertiesAll.putAll(propertiesFromDerived); - } - } - } - } - return Either.left(propertiesAll); - } - - protected TitanOperationStatus setArtifactsFromGraph(GraphVertex componentV, ToscaElement toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ARTIFACTS); - if (result.isLeft()) { - toscaElement.setArtifacts(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - result = getDataFromGraph(componentV, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS); - if (result.isLeft()) { - toscaElement.setDeploymentArtifacts(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - result = getDataFromGraph(componentV, EdgeLabelEnum.TOSCA_ARTIFACTS); - if (result.isLeft()) { - toscaElement.setToscaArtifacts(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - protected TitanOperationStatus setAllVersions(GraphVertex componentV, ToscaElement toscaElement) { - Map allVersion = new HashMap<>(); - - allVersion.put((String) componentV.getMetadataProperty(GraphPropertyEnum.VERSION), componentV.getUniqueId()); - ArrayList allChildrenAndParants = new ArrayList<>(); - Either childResourceRes = titanDao.getChildVertex(componentV, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - while (childResourceRes.isLeft()) { - GraphVertex child = childResourceRes.left().value(); - allChildrenAndParants.add(child); - childResourceRes = titanDao.getChildVertex(child, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - } - TitanOperationStatus operationStatus = childResourceRes.right().value(); - - if (operationStatus != TitanOperationStatus.NOT_FOUND) { - return operationStatus; - } else { - Either parentResourceRes = titanDao.getParentVertex(componentV, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - while (parentResourceRes.isLeft()) { - GraphVertex parent = parentResourceRes.left().value(); - allChildrenAndParants.add(parent); - parentResourceRes = titanDao.getParentVertex(parent, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - } - operationStatus = parentResourceRes.right().value(); - if (operationStatus != TitanOperationStatus.NOT_FOUND) { - return operationStatus; - } else { - allChildrenAndParants.stream().filter(vertex -> { - Boolean isDeleted = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_DELETED); - return (isDeleted == null || !isDeleted); - }).forEach(vertex -> allVersion.put((String) vertex.getMetadataProperty(GraphPropertyEnum.VERSION), vertex.getUniqueId())); - - toscaElement.setAllVersions(allVersion); - return TitanOperationStatus.OK; - } - } - } - - protected Either, StorageOperationStatus> getFollowedComponent(String userId, Set lifecycleStates, Set lastStateStates, ComponentTypeEnum neededType) { - - Either, StorageOperationStatus> result = null; - - Map props = null; - - if (userId != null) { - props = new EnumMap<>(GraphPropertyEnum.class); - // for Designer retrieve specific user - props.put(GraphPropertyEnum.USERID, userId); - } - // in case of user id == null -> get all users by label - // for Tester and Admin retrieve all users - Either, TitanOperationStatus> usersByCriteria = titanDao.getByCriteria(VertexTypeEnum.USER, props, JsonParseFlagEnum.NoParse); - if (usersByCriteria.isRight()) { - log.debug("Failed to fetch users by criteria {} error {}", props, usersByCriteria.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(usersByCriteria.right().value())); - } - List users = usersByCriteria.left().value(); - - List components = new ArrayList<>(); - List componentsPerUser; - for (GraphVertex userV : users) { - - HashSet ids = new HashSet<>(); - Either, TitanOperationStatus> childrenVertecies = titanDao.getChildrenVertecies(userV, EdgeLabelEnum.STATE, JsonParseFlagEnum.NoParse); - if (childrenVertecies.isRight() && childrenVertecies.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("Failed to fetch children vertices for user {} by edge {} error {}", userV.getMetadataProperty(GraphPropertyEnum.USERID), EdgeLabelEnum.STATE, childrenVertecies.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenVertecies.right().value())); - } - - // get all resource with current state - if (childrenVertecies.isLeft()) { - componentsPerUser = fetchComponents(lifecycleStates, childrenVertecies.left().value(), neededType, EdgeLabelEnum.STATE); - - if (componentsPerUser != null) { - for (T comp : componentsPerUser) { - ids.add(comp.getUniqueId()); - components.add(comp); - } - } - } - if (lastStateStates != null && !lastStateStates.isEmpty()) { - // get all resource with last state - childrenVertecies = titanDao.getChildrenVertecies(userV, EdgeLabelEnum.LAST_STATE, JsonParseFlagEnum.NoParse); - if (childrenVertecies.isRight() && childrenVertecies.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("Failed to fetch children vertices for user {} by edge {} error {}", userV.getMetadataProperty(GraphPropertyEnum.USERID), EdgeLabelEnum.LAST_STATE, childrenVertecies.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenVertecies.right().value())); - } - if (childrenVertecies.isLeft()) { - boolean isFirst; - componentsPerUser = fetchComponents(lastStateStates, childrenVertecies.left().value(), neededType, EdgeLabelEnum.LAST_STATE); - if (componentsPerUser != null) { - for (T comp : componentsPerUser) { - isFirst = true; - - if (ids.contains(comp.getUniqueId())) { - isFirst = false; - } - if (isFirst) { - components.add(comp); - } - - } - } - } - } - - } // whlile users - ; - result = Either.left(components); - return result; - - } - - private List fetchComponents(Set lifecycleStates, List vertices, ComponentTypeEnum neededType, EdgeLabelEnum edgelabel) { - List components = new ArrayList<>(); - for (GraphVertex node : vertices) { - - Iterator edges = node.getVertex().edges(Direction.IN, edgelabel.name()); - while (edges.hasNext()) { - Edge edge = edges.next(); - String stateStr = (String) titanDao.getProperty(edge, EdgePropertyEnum.STATE); - - LifecycleStateEnum nodeState = LifecycleStateEnum.findState(stateStr); - if (nodeState == null) { - log.debug("no supported STATE {} for element {}", stateStr, node.getUniqueId()); - continue; - } - if (lifecycleStates != null && lifecycleStates.contains(nodeState)) { - - Boolean isDeleted = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_DELETED); - Boolean isArchived = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); - if (isDeleted != null && isDeleted || isArchived != null && isArchived) { - log.trace("Deleted/Archived element {}, discard", node.getUniqueId()); - continue; - } - - Boolean isHighest = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - if (isHighest) { - - ComponentTypeEnum componentType = node.getType(); - // get only latest versions - - if (componentType == null) { - log.debug("No supported type {} for vertex {}", componentType, node.getUniqueId()); - continue; - } - if (neededType == componentType) { - switch (componentType) { - case SERVICE: - case PRODUCT: - handleNode(components, node, componentType); - break; - case RESOURCE: - Boolean isAbtract = (Boolean) node.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT); - if (isAbtract == null || !isAbtract) { - handleNode(components, node, componentType); - } // if not abstract - break; - default: - log.debug("not supported node type {}", componentType); - break; - }// case - } // needed type - } - } // if - } // while edges - } // while resources - return components; - } - - protected void handleNode(List components, GraphVertex vertexComponent, ComponentTypeEnum nodeType) { - - Either component = getLightComponent(vertexComponent, nodeType, new ComponentParametersView(true)); - if (component.isRight()) { - log.debug("Failed to get component for id = {} error : {} skip resource", vertexComponent.getUniqueId(), component.right().value()); - } else { - components.add(component.left().value()); - } - } - - protected Either getLightComponent(String componentUid, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { - Either getVertexRes = titanDao.getVertexById(componentUid); - if (getVertexRes.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexRes.right().value())); - } - return getLightComponent(getVertexRes.left().value(), nodeType, parametersFilter); - } - - protected Either getLightComponent(GraphVertex vertexComponent, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { - - log.trace("Starting to build light component of type {}, id {}", nodeType, vertexComponent.getUniqueId()); - - titanDao.parseVertexProperties(vertexComponent, JsonParseFlagEnum.ParseMetadata); - - T toscaElement = convertToComponent(vertexComponent); - - TitanOperationStatus status = setCreatorFromGraph(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - - status = setLastModifierFromGraph(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - status = setCategoriesFromGraph(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (!parametersFilter.isIgnoreAllVersions()) { - status = setAllVersions(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!parametersFilter.isIgnoreCapabilities()) { - status = setCapabilitiesFromGraph(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - if (!parametersFilter.isIgnoreRequirements()) { - status = setRequirementsFromGraph(vertexComponent, toscaElement); - if (status != TitanOperationStatus.OK) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - } - log.debug("Ended to build light component of type {}, id {}", nodeType, vertexComponent.getUniqueId()); - return Either.left(toscaElement); - } - - @SuppressWarnings("unchecked") - protected T convertToComponent(GraphVertex componentV) { - ToscaElement toscaElement = null; - VertexTypeEnum label = componentV.getLabel(); - switch (label) { - case NODE_TYPE: - toscaElement = new NodeType(); - break; - case TOPOLOGY_TEMPLATE: - toscaElement = new TopologyTemplate(); - break; - default: - log.debug("Not supported tosca type {}", label); - break; - } - - Map jsonMetada = componentV.getMetadataJson(); - if (toscaElement != null) { - toscaElement.setMetadata(jsonMetada); - } - return (T) toscaElement; - } - - protected TitanOperationStatus setResourceCategoryFromGraphV(Vertex vertex, CatalogComponent catalogComponent) { - - Either childVertex = titanDao.getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, catalogComponent.getUniqueId(), childVertex.right().value()); - return childVertex.right().value(); - } - Vertex subCategoryV = childVertex.left().value(); - catalogComponent.setSubCategoryNormalizedName((String) subCategoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); - Either parentVertex = titanDao.getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); - Vertex categoryV = parentVertex.left().value(); - catalogComponent.setCategoryNormalizedName((String) categoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); - - return TitanOperationStatus.OK; - } - - protected TitanOperationStatus setServiceCategoryFromGraphV(Vertex vertex, CatalogComponent catalogComponent) { - Either childVertex = titanDao.getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, catalogComponent.getUniqueId(), childVertex.right().value()); - return childVertex.right().value(); - } - Vertex categoryV = childVertex.left().value(); - catalogComponent.setCategoryNormalizedName((String) categoryV.property(JsonPresentationFields.NORMALIZED_NAME.getPresentation()).value()); - - return TitanOperationStatus.OK; - } - - protected TitanOperationStatus setResourceCategoryFromGraph(GraphVertex componentV, ToscaElement toscaElement) { - List categories = new ArrayList<>(); - SubCategoryDefinition subcategory; - - Either childVertex = titanDao.getChildVertex(componentV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, componentV.getUniqueId(), childVertex.right().value()); - return childVertex.right().value(); - } - GraphVertex subCategoryV = childVertex.left().value(); - Map metadataProperties = subCategoryV.getMetadataProperties(); - subcategory = new SubCategoryDefinition(); - subcategory.setUniqueId(subCategoryV.getUniqueId()); - subcategory.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); - subcategory.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); - - Type listTypeSubcat = new TypeToken>() { - }.getType(); - List iconsfromJsonSubcat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS), listTypeSubcat); - subcategory.setIcons(iconsfromJsonSubcat); - - Either parentVertex = titanDao.getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); - if (parentVertex.isRight()) { - log.debug("failed to fetch {} for category with id {}, error {}", EdgeLabelEnum.SUB_CATEGORY, subCategoryV.getUniqueId(), parentVertex.right().value()); - return childVertex.right().value(); - } - GraphVertex categoryV = parentVertex.left().value(); - metadataProperties = categoryV.getMetadataProperties(); - - CategoryDefinition category = new CategoryDefinition(); - category.setUniqueId(categoryV.getUniqueId()); - category.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME)); - category.setName((String) metadataProperties.get(GraphPropertyEnum.NAME)); - - Type listTypeCat = new TypeToken>() { - }.getType(); - List iconsfromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS), listTypeCat); - category.setIcons(iconsfromJsonCat); - - category.addSubCategory(subcategory); - categories.add(category); - toscaElement.setCategories(categories); - - return TitanOperationStatus.OK; - } - - public Either updateToscaElement(T toscaElementToUpdate, GraphVertex elementV, ComponentParametersView filterResult) { - Either result = null; - - log.debug("In updateToscaElement. received component uid = {}", (toscaElementToUpdate == null ? null : toscaElementToUpdate.getUniqueId())); - if (toscaElementToUpdate == null) { - log.error("Service object is null"); - result = Either.right(StorageOperationStatus.BAD_REQUEST); - return result; - } - - String modifierUserId = toscaElementToUpdate.getLastUpdaterUserId(); - if (modifierUserId == null || modifierUserId.isEmpty()) { - log.error("UserId is missing in the request."); - result = Either.right(StorageOperationStatus.BAD_REQUEST); - return result; - } - Either findUser = findUserVertex(modifierUserId); - - if (findUser.isRight()) { - TitanOperationStatus status = findUser.right().value(); - log.error(CANNOT_FIND_USER_IN_THE_GRAPH_STATUS_IS, modifierUserId, status); - return result; - } - - GraphVertex modifierV = findUser.left().value(); - String toscaElementId = toscaElementToUpdate.getUniqueId(); - - Either parentVertex = titanDao.getParentVertex(elementV, EdgeLabelEnum.LAST_MODIFIER, JsonParseFlagEnum.NoParse); - if (parentVertex.isRight()) { - log.debug("Failed to fetch last modifier for tosca element with id {} error {}", toscaElementId, parentVertex.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentVertex.right().value())); - } - GraphVertex userV = parentVertex.left().value(); - String currentModifier = (String) userV.getMetadataProperty(GraphPropertyEnum.USERID); - - String prevSystemName = (String) elementV.getMetadataProperty(GraphPropertyEnum.SYSTEM_NAME); - - if (currentModifier.equals(modifierUserId)) { - log.debug("Graph LAST MODIFIER edge should not be changed since the modifier is the same as the last modifier."); - } else { - log.debug("Going to update the last modifier user of the resource from {} to {}", currentModifier, modifierUserId); - StorageOperationStatus status = moveLastModifierEdge(elementV, modifierV); - log.debug("Finish to update the last modifier user of the resource from {} to {}. status is {}", currentModifier, modifierUserId, status); - if (status != StorageOperationStatus.OK) { - result = Either.right(status); - return result; - } - } - - final long currentTimeMillis = System.currentTimeMillis(); - log.debug("Going to update the last Update Date of the resource from {} to {}", elementV.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE), currentTimeMillis); - elementV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, currentTimeMillis); - - StorageOperationStatus checkCategories = validateCategories(toscaElementToUpdate, elementV); - if (checkCategories != StorageOperationStatus.OK) { - result = Either.right(checkCategories); - return result; - } - - // update all data on vertex - fillToscaElementVertexData(elementV, toscaElementToUpdate, JsonParseFlagEnum.ParseMetadata); - - Either updateElement = titanDao.updateVertex(elementV); - - if (updateElement.isRight()) { - log.error("Failed to update resource {}. status is {}", toscaElementId, updateElement.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value())); - return result; - } - GraphVertex updateElementV = updateElement.left().value(); - - // DE230195 in case resource name changed update TOSCA artifacts - // file names accordingly - String newSystemName = (String) updateElementV.getMetadataProperty(GraphPropertyEnum.SYSTEM_NAME); - if (newSystemName != null && !newSystemName.equals(prevSystemName)) { - Either, TitanOperationStatus> resultToscaArt = getDataFromGraph(updateElementV, EdgeLabelEnum.TOSCA_ARTIFACTS); - if (resultToscaArt.isRight()) { - log.debug("Failed to get tosca artifact from graph for tosca element {} error {}", toscaElementId, resultToscaArt.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(resultToscaArt.right().value())); - } - - Map toscaArtifacts = resultToscaArt.left().value(); - if (toscaArtifacts != null) { - for (Entry artifact : toscaArtifacts.entrySet()) { - generateNewToscaFileName(toscaElementToUpdate.getComponentType().getValue().toLowerCase(), newSystemName, artifact.getValue()); - } - // TODO call to new Artifact operation in order to update list of artifacts - - } - } - - if (toscaElementToUpdate.getComponentType() == ComponentTypeEnum.RESOURCE) { - StorageOperationStatus resultDerived = updateDerived(toscaElementToUpdate, updateElementV); - if (resultDerived != StorageOperationStatus.OK) { - log.debug("Failed to update from derived data for element {} error {}", toscaElementId, resultDerived); - return Either.right(resultDerived); - } - } - - Either updatedResource = getToscaElement(updateElementV, filterResult); - if (updatedResource.isRight()) { - log.error("Failed to fetch tosca element {} after update , error {}", toscaElementId, updatedResource.right().value()); - result = Either.right(StorageOperationStatus.BAD_REQUEST); - return result; - } - - T updatedResourceValue = updatedResource.left().value(); - result = Either.left(updatedResourceValue); - - return result; - } - - protected StorageOperationStatus moveLastModifierEdge(GraphVertex elementV, GraphVertex modifierV) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(titanDao.moveEdge(elementV, modifierV, EdgeLabelEnum.LAST_MODIFIER, Direction.IN)); - } - - protected StorageOperationStatus moveCategoryEdge(GraphVertex elementV, GraphVertex categoryV) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(titanDao.moveEdge(elementV, categoryV, EdgeLabelEnum.CATEGORY, Direction.OUT)); - } - - private void generateNewToscaFileName(String componentType, String componentName, ArtifactDataDefinition artifactInfo) { - Map getConfig = (Map) ConfigurationManager.getConfigurationManager().getConfiguration().getToscaArtifacts().entrySet().stream().filter(p -> p.getKey().equalsIgnoreCase(artifactInfo.getArtifactLabel())) - .findAny().get().getValue(); - artifactInfo.setArtifactName(componentType + "-" + componentName + getConfig.get("artifactName")); - } - - protected StorageOperationStatus validateResourceCategory(T toscaElementToUpdate, GraphVertex elementV) { - StorageOperationStatus status = StorageOperationStatus.OK; - List newCategoryList = toscaElementToUpdate.getCategories(); - CategoryDefinition newCategory = newCategoryList.get(0); - - Either childVertex = titanDao.getChildVertex(elementV, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse); - if (childVertex.isRight()) { - log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, EdgeLabelEnum.CATEGORY, elementV.getUniqueId(), childVertex.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(childVertex.right().value()); - } - GraphVertex subCategoryV = childVertex.left().value(); - Map metadataProperties = subCategoryV.getMetadataProperties(); - String subCategoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); - - Either parentVertex = titanDao.getParentVertex(subCategoryV, EdgeLabelEnum.SUB_CATEGORY, JsonParseFlagEnum.NoParse); - if (parentVertex.isRight()) { - log.debug("failed to fetch {} for category with id {}, error {}", EdgeLabelEnum.SUB_CATEGORY, subCategoryV.getUniqueId(), parentVertex.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(childVertex.right().value()); - } - GraphVertex categoryV = parentVertex.left().value(); - metadataProperties = categoryV.getMetadataProperties(); - String categoryNameCurrent = (String) metadataProperties.get(GraphPropertyEnum.NAME); - - boolean categoryWasChanged = false; - - String newCategoryName = newCategory.getName(); - SubCategoryDefinition newSubcategory = newCategory.getSubcategories().get(0); - String newSubCategoryName = newSubcategory.getName(); - if (newCategoryName != null && !newCategoryName.equals(categoryNameCurrent)) { - // the category was changed - categoryWasChanged = true; - } else { - // the sub-category was changed - if (newSubCategoryName != null && !newSubCategoryName.equals(subCategoryNameCurrent)) { - log.debug("Going to update the category of the resource from {} to {}", categoryNameCurrent, newCategory); - categoryWasChanged = true; - } - } - if (categoryWasChanged) { - Either getCategoryVertex = getResourceCategoryVertex(elementV.getUniqueId(), newSubCategoryName, newCategoryName); - - if (getCategoryVertex.isRight()) { - return getCategoryVertex.right().value(); - } - GraphVertex newCategoryV = getCategoryVertex.left().value(); - status = moveCategoryEdge(elementV, newCategoryV); - log.debug("Going to update the category of the resource from {} to {}. status is {}", categoryNameCurrent, newCategory, status); - } - return status; - } - - public Either, StorageOperationStatus> getElementCatalogData(ComponentTypeEnum componentType, List excludeTypes, boolean isHighestVersions) { - Either, TitanOperationStatus> listOfComponents; - if (isHighestVersions) { - listOfComponents = getListOfHighestComponents(componentType, excludeTypes, JsonParseFlagEnum.NoParse); - } else { - listOfComponents = getListOfHighestAndAllCertifiedComponents(componentType, excludeTypes); - } - - if (listOfComponents.isRight() && listOfComponents.right().value() != TitanOperationStatus.NOT_FOUND) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(listOfComponents.right().value())); - } - List result = new ArrayList<>(); - if (listOfComponents.isLeft()) { - List highestAndAllCertified = listOfComponents.left().value(); - if (highestAndAllCertified != null && !highestAndAllCertified.isEmpty()) { - for (GraphVertex vertexComponent : highestAndAllCertified) { - Either component = getLightComponent(vertexComponent, componentType, new ComponentParametersView(true)); - if (component.isRight()) { - log.debug("Failed to fetch light element for {} error {}", vertexComponent.getUniqueId(), component.right().value()); - return Either.right(component.right().value()); - } else { - result.add(component.left().value()); - } - } - } - } - return Either.left(result); - } - - public Either, StorageOperationStatus> getElementCatalogData(boolean isCatalog, List excludeTypes) { - StopWatch stopWatch = new StopWatch(); - stopWatch.start(); - - Map existInCatalog = new HashMap<>(); - Either, TitanOperationStatus> verticesEither = titanDao.getCatalogOrArchiveVerticies(isCatalog); - if (verticesEither.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(verticesEither.right().value())); - } - Iterator vertices = verticesEither.left().value(); - while (vertices.hasNext()) { - handleCatalogComponent(existInCatalog, vertices.next(), excludeTypes); - } - stopWatch.stop(); - String timeToFetchElements = stopWatch.prettyPrint(); - log.info("time to fetch all catalog elements: {}", timeToFetchElements); - return Either.left(existInCatalog.values().stream().collect(Collectors.toList())); - } - - private void handleCatalogComponent(Map existInCatalog, Vertex vertex, List excludeTypes) { - VertexProperty property = vertex.property(GraphPropertiesDictionary.METADATA.getProperty()); - String json = (String) property.value(); - Map metadatObj = JsonParserUtils.toMap(json); - - String uniqueId = (String) metadatObj.get(JsonPresentationFields.UNIQUE_ID.getPresentation()); - Boolean isDeleted = (Boolean) metadatObj.get(JsonPresentationFields.IS_DELETED.getPresentation()); - - - if (isAddToCatalog(excludeTypes, metadatObj) && (existInCatalog.get(uniqueId) == null && (isDeleted == null || !isDeleted.booleanValue()))) { - CatalogComponent catalogComponent = new CatalogComponent(); - catalogComponent.setUniqueId(uniqueId); - - catalogComponent.setComponentType(ComponentTypeEnum.valueOf((String) metadatObj.get(JsonPresentationFields.COMPONENT_TYPE.getPresentation()))); - catalogComponent.setVersion((String) metadatObj.get(JsonPresentationFields.VERSION.getPresentation())); - catalogComponent.setName((String) metadatObj.get(JsonPresentationFields.NAME.getPresentation())); - catalogComponent.setIcon((String) metadatObj.get(JsonPresentationFields.ICON.getPresentation())); - catalogComponent.setLifecycleState((String) metadatObj.get(JsonPresentationFields.LIFECYCLE_STATE.getPresentation())); - catalogComponent.setLastUpdateDate((Long) metadatObj.get(JsonPresentationFields.LAST_UPDATE_DATE.getPresentation())); - catalogComponent.setDistributionStatus((String) metadatObj.get(JsonPresentationFields.DISTRIBUTION_STATUS.getPresentation())); - Object resourceType = metadatObj.get(JsonPresentationFields.RESOURCE_TYPE.getPresentation()); - if (resourceType != null) { - catalogComponent.setResourceType((String) resourceType); - } - - if (catalogComponent.getComponentType() == ComponentTypeEnum.SERVICE) { - setServiceCategoryFromGraphV(vertex, catalogComponent); - - } else { - setResourceCategoryFromGraphV(vertex, catalogComponent); - } - List tags = (List) metadatObj.get(JsonPresentationFields.TAGS.getPresentation()); - if (tags != null) { - catalogComponent.setTags(tags); - } - existInCatalog.put(uniqueId, catalogComponent); - } - } - - private boolean isAddToCatalog(List excludeTypes, Map metadatObj) { - boolean isAddToCatalog = true; - Object resourceTypeStr = metadatObj.get(JsonPresentationFields.RESOURCE_TYPE.getPresentation()); - if (resourceTypeStr != null) { - ResourceTypeEnum resourceType = ResourceTypeEnum.getType((String) resourceTypeStr); - if (!CollectionUtils.isEmpty(excludeTypes)) { - Optional op = excludeTypes.stream().filter(rt -> rt == resourceType).findAny(); - if (op.isPresent()) - isAddToCatalog = false; - } - } - return isAddToCatalog; - } - - public Either, TitanOperationStatus> getListOfHighestComponents(ComponentTypeEnum - componentType, List excludeTypes, JsonParseFlagEnum parseFlag) { - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesHasNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - if (componentType == ComponentTypeEnum.RESOURCE) { - propertiesToMatch.put(GraphPropertyEnum.IS_ABSTRACT, false); - propertiesHasNotToMatch.put(GraphPropertyEnum.RESOURCE_TYPE, excludeTypes); - } - propertiesHasNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - propertiesHasNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 - - return titanDao.getByCriteria(null, propertiesToMatch, propertiesHasNotToMatch, parseFlag); - } - - // highest + (certified && !highest) - public Either, TitanOperationStatus> getListOfHighestAndAllCertifiedComponents - (ComponentTypeEnum componentType, List excludeTypes) { - long startFetchAllStates = System.currentTimeMillis(); - Either, TitanOperationStatus> highestNodes = getListOfHighestComponents(componentType, excludeTypes, JsonParseFlagEnum.ParseMetadata); - - Map propertiesToMatchCertified = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesHasNotToMatchCertified = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatchCertified.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - propertiesToMatchCertified.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - if (componentType == ComponentTypeEnum.RESOURCE) { - propertiesToMatchCertified.put(GraphPropertyEnum.IS_ABSTRACT, false); - propertiesHasNotToMatchCertified.put(GraphPropertyEnum.RESOURCE_TYPE, excludeTypes); - } - - propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_DELETED, true); - propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 - propertiesHasNotToMatchCertified.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - Either, TitanOperationStatus> certifiedNotHighestNodes = titanDao.getByCriteria(null, propertiesToMatchCertified, propertiesHasNotToMatchCertified, JsonParseFlagEnum.ParseMetadata); - if (certifiedNotHighestNodes.isRight() && certifiedNotHighestNodes.right().value() != TitanOperationStatus.NOT_FOUND) { - return Either.right(certifiedNotHighestNodes.right().value()); - } - - long endFetchAllStates = System.currentTimeMillis(); - - List allNodes = new ArrayList<>(); - - if (certifiedNotHighestNodes.isLeft()) { - allNodes.addAll(certifiedNotHighestNodes.left().value()); - } - if (highestNodes.isLeft()) { - allNodes.addAll(highestNodes.left().value()); - } - - log.debug("Fetch catalog {}s all states from graph took {} ms", componentType, endFetchAllStates - startFetchAllStates); - return Either.left(allNodes); - } - - protected Either, StorageOperationStatus> getAllComponentsMarkedForDeletion(ComponentTypeEnum - componentType) { - - // get all components marked for delete - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.IS_DELETED, true); - props.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - - Either, TitanOperationStatus> componentsToDelete = titanDao.getByCriteria(null, props, JsonParseFlagEnum.NoParse); - - if (componentsToDelete.isRight()) { - TitanOperationStatus error = componentsToDelete.right().value(); - if (error.equals(TitanOperationStatus.NOT_FOUND)) { - log.trace("no components to delete"); - return Either.left(new ArrayList<>()); - } else { - log.info("failed to find components to delete. error : {}", error.name()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); - } - } - return Either.left(componentsToDelete.left().value()); - } - - protected TitanOperationStatus setAdditionalInformationFromGraph(GraphVertex componentV, ToscaElement - toscaElement) { - Either, TitanOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ADDITIONAL_INFORMATION); - if (result.isLeft()) { - toscaElement.setAdditionalInformation(result.left().value()); - } else { - if (result.right().value() != TitanOperationStatus.NOT_FOUND) { - return result.right().value(); - } - } - return TitanOperationStatus.OK; - } - - // -------------------------------------------- - public abstract Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView); - - public abstract Either getToscaElement(GraphVertex toscaElementVertex, ComponentParametersView componentParametersView); - - public abstract Either deleteToscaElement(GraphVertex toscaElementVertex); - - public abstract Either createToscaElement(ToscaElement toscaElement); - - protected abstract TitanOperationStatus - setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement); - - protected abstract TitanOperationStatus - setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement); - - protected abstract TitanOperationStatus - setRequirementsFromGraph(GraphVertex componentV, T toscaElement); - - protected abstract StorageOperationStatus - validateCategories(T toscaElementToUpdate, GraphVertex elementV); - - protected abstract StorageOperationStatus - updateDerived(T toscaElementToUpdate, GraphVertex updateElementV); - - public abstract void fillToscaElementVertexData(GraphVertex elementV, T - toscaElementToUpdate, JsonParseFlagEnum flag); - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java deleted file mode 100644 index dd9c3ca29e..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java +++ /dev/null @@ -1,2743 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.*; -import org.openecomp.sdc.be.model.*; -import org.openecomp.sdc.be.model.catalog.CatalogComponent; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; -import org.openecomp.sdc.be.model.operations.StorageException; -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.UniqueIdBuilder; -import org.openecomp.sdc.be.resources.data.ComponentMetadataData; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility; -import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.openecomp.sdc.common.util.ValidationUtils; -import org.springframework.beans.factory.annotation.Autowired; - -import java.util.*; -import java.util.Map.Entry; -import java.util.function.BiPredicate; -import java.util.stream.Collectors; - -import static java.util.Objects.requireNonNull; -import static org.apache.commons.collections.CollectionUtils.isEmpty; -import static org.apache.commons.collections.CollectionUtils.isNotEmpty; - - -@org.springframework.stereotype.Component("tosca-operation-facade") -public class ToscaOperationFacade { - - // region - Fields - - private static final String COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch a component with and UniqueId {}, error: {}"; - private static final String FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS = "Failed to find recently added property {} on the resource {}. Status is {}. "; - private static final String FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS = "Failed to get updated resource {}. Status is {}. "; - private static final String FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS = "Failed to add the property {} to the resource {}. Status is {}. "; - private static final String SERVICE = "service"; - private static final String NOT_SUPPORTED_COMPONENT_TYPE = "Not supported component type {}"; - private static final String COMPONENT_CREATED_SUCCESSFULLY = "Component created successfully!!!"; - private static final String COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR = "Couldn't fetch component with and unique id {}, error: {}"; - @Autowired - private NodeTypeOperation nodeTypeOperation; - @Autowired - private TopologyTemplateOperation topologyTemplateOperation; - @Autowired - private NodeTemplateOperation nodeTemplateOperation; - @Autowired - private GroupsOperation groupsOperation; - @Autowired - private HealingTitanDao titanDao; - - private static final Logger log = Logger.getLogger(ToscaOperationFacade.class.getName()); - // endregion - - // region - ToscaElement - GetById - public static final String PROXY_SUFFIX = "_proxy"; - - public Either getToscaFullElement(String componentId) { - ComponentParametersView filters = new ComponentParametersView(); - filters.setIgnoreCapabiltyProperties(false); - filters.setIgnoreForwardingPath(false); - return getToscaElement(componentId, filters); - } - - public Either getToscaElement(String componentId) { - - return getToscaElement(componentId, JsonParseFlagEnum.ParseAll); - - } - - public Either getToscaElement(String componentId, ComponentParametersView filters) { - - Either getVertexEither = titanDao.getVertexById(componentId, filters.detectParseFlag()); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - return getToscaElementByOperation(getVertexEither.left().value(), filters); - } - - public Either getToscaElement(String componentId, JsonParseFlagEnum parseFlag) { - - Either getVertexEither = titanDao.getVertexById(componentId, parseFlag); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - return getToscaElementByOperation(getVertexEither.left().value()); - } - - public Either getToscaElement(GraphVertex componentVertex) { - return getToscaElementByOperation(componentVertex); - } - - public Either validateComponentExists(String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - TitanOperationStatus status = getVertexEither.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - return Either.left(false); - } else { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } - } - return Either.left(true); - } - - public Either findLastCertifiedToscaElementByUUID(T component) { - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.UUID, component.getUUID()); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - Either, TitanOperationStatus> getVertexEither = titanDao.getByCriteria(ModelConverter.getVertexType(component), props); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, component.getUniqueId(), getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - return getToscaElementByOperation(getVertexEither.left().value().get(0)); - } - - // endregion - // region - ToscaElement - GetByOperation - private Either getToscaElementByOperation(GraphVertex componentV) { - return getToscaElementByOperation(componentV, new ComponentParametersView()); - } - - private Either getToscaElementByOperation(GraphVertex componentV, ComponentParametersView filters) { - VertexTypeEnum label = componentV.getLabel(); - - ToscaElementOperation toscaOperation = getToscaElementOperation(componentV); - log.debug("getToscaElementByOperation: toscaOperation={}", toscaOperation.getClass()); - Either toscaElement; - String componentId = componentV.getUniqueId(); - if (toscaOperation != null) { - log.debug("Need to fetch tosca element for id {}", componentId); - toscaElement = toscaOperation.getToscaElement(componentV, filters); - } else { - log.debug("not supported tosca type {} for id {}", label, componentId); - toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); - } - if (toscaElement.isRight()) { - return Either.right(toscaElement.right().value()); - } - return Either.left(ModelConverter.convertFromToscaElement(toscaElement.left().value())); - } - - // endregion - private ToscaElementOperation getToscaElementOperation(GraphVertex componentV) { - VertexTypeEnum label = componentV.getLabel(); - switch (label) { - case NODE_TYPE: - return nodeTypeOperation; - case TOPOLOGY_TEMPLATE: - return topologyTemplateOperation; - default: - return null; - } - } - - public Either createToscaComponent(T resource) { - ToscaElement toscaElement = ModelConverter.convertToToscaElement(resource); - - ToscaElementOperation toscaElementOperation = getToscaElementOperation(resource); - Either createToscaElement = toscaElementOperation.createToscaElement(toscaElement); - if (createToscaElement.isLeft()) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - T dataModel = ModelConverter.convertFromToscaElement(createToscaElement.left().value()); - return Either.left(dataModel); - } - return Either.right(createToscaElement.right().value()); - } - - // region - ToscaElement Delete - public StorageOperationStatus markComponentToDelete(Component componentToDelete) { - - if ((componentToDelete.getIsDeleted() != null) && componentToDelete.getIsDeleted() && !componentToDelete.isHighestVersion()) { - // component already marked for delete - return StorageOperationStatus.OK; - } else { - - Either getResponse = titanDao.getVertexById(componentToDelete.getUniqueId(), JsonParseFlagEnum.ParseAll); - if (getResponse.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentToDelete.getUniqueId(), getResponse.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getResponse.right().value()); - - } - GraphVertex componentV = getResponse.left().value(); - - // same operation for node type and topology template operations - Either result = nodeTypeOperation.markComponentToDelete(componentV); - if (result.isRight()) { - return result.right().value(); - } - return StorageOperationStatus.OK; - } - } - - public Either deleteToscaComponent(String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (getVertexEither.isRight()) { - log.debug("Couldn't fetch component vertex with and unique id {}, error: {}", componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - Either deleteElement = deleteToscaElement(getVertexEither.left().value()); - if (deleteElement.isRight()) { - log.debug("Failed to delete component with and unique id {}, error: {}", componentId, deleteElement.right().value()); - return Either.right(deleteElement.right().value()); - } - T dataModel = ModelConverter.convertFromToscaElement(deleteElement.left().value()); - - return Either.left(dataModel); - } - - private Either deleteToscaElement(GraphVertex componentV) { - VertexTypeEnum label = componentV.getLabel(); - Either toscaElement; - Object componentId = componentV.getUniqueId(); - switch (label) { - case NODE_TYPE: - log.debug("Need to fetch node type for id {}", componentId); - toscaElement = nodeTypeOperation.deleteToscaElement(componentV); - break; - case TOPOLOGY_TEMPLATE: - log.debug("Need to fetch topology template for id {}", componentId); - toscaElement = topologyTemplateOperation.deleteToscaElement(componentV); - break; - default: - log.debug("not supported tosca type {} for id {}", label, componentId); - toscaElement = Either.right(StorageOperationStatus.BAD_REQUEST); - break; - } - return toscaElement; - } - // endregion - - private ToscaElementOperation getToscaElementOperation(Component component) { - return ModelConverter.isAtomicComponent(component) ? nodeTypeOperation : topologyTemplateOperation; - } - - public Either getLatestByToscaResourceName(String toscaResourceName) { - return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); - } - - public Either getFullLatestComponentByToscaResourceName(String toscaResourceName) { - ComponentParametersView fetchAllFilter = new ComponentParametersView(); - fetchAllFilter.setIgnoreForwardingPath(true); - fetchAllFilter.setIgnoreCapabiltyProperties(false); - return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName, JsonParseFlagEnum.ParseAll, fetchAllFilter); - } - - public Either getLatestByName(String resourceName) { - return getLatestByName(GraphPropertyEnum.NAME, resourceName); - - } - - public StorageOperationStatus validateCsarUuidUniqueness(String csarUUID) { - - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); - - Either, TitanOperationStatus> resources = titanDao.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); - - if (resources.isRight()) { - if (resources.right().value() == TitanOperationStatus.NOT_FOUND) { - return StorageOperationStatus.OK; - } else { - log.debug("failed to get resources from graph with property name: {}", csarUUID); - return DaoStatusConverter.convertTitanStatusToStorageStatus(resources.right().value()); - } - } - return StorageOperationStatus.ENTITY_ALREADY_EXISTS; - - } - - public Either, StorageOperationStatus> getFollowed(String userId, Set lifecycleStates, Set lastStateStates, ComponentTypeEnum componentType) { - Either, StorageOperationStatus> followedResources; - if (componentType == ComponentTypeEnum.RESOURCE) { - followedResources = nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); - } else { - followedResources = topologyTemplateOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType); - } - - Set components = new HashSet<>(); - if (followedResources.isRight() && followedResources.right().value() != StorageOperationStatus.NOT_FOUND) { - return Either.right(followedResources.right().value()); - } - if (followedResources.isLeft()) { - List toscaElements = followedResources.left().value(); - toscaElements.forEach(te -> { - T component = ModelConverter.convertFromToscaElement(te); - components.add(component); - }); - } - return Either.left(components); - } - - public Either getLatestCertifiedNodeTypeByToscaResourceName(String toscaResourceName) { - - return getLatestCertifiedByToscaResourceName(toscaResourceName, VertexTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata); - } - - public Either getLatestCertifiedByToscaResourceName(String toscaResourceName, VertexTypeEnum vertexType, JsonParseFlagEnum parseFlag) { - - Either result = null; - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - Either, TitanOperationStatus> getLatestRes = titanDao.getByCriteria(vertexType, props, parseFlag); - - if (getLatestRes.isRight()) { - TitanOperationStatus status = getLatestRes.right().value(); - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch {} with name {}. status={} ", vertexType, toscaResourceName, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - List resources = getLatestRes.left().value(); - double version = 0.0; - GraphVertex highestResource = null; - for (GraphVertex resource : resources) { - double resourceVersion = Double.parseDouble((String) resource.getJsonMetadataField(JsonPresentationFields.VERSION)); - if (resourceVersion > version) { - version = resourceVersion; - highestResource = resource; - } - } - result = getToscaFullElement(highestResource.getUniqueId()); - } - return result; - } - - public Either validateToscaResourceNameExists(String templateName) { - Either validateUniquenessRes = validateToscaResourceNameUniqueness(templateName); - if (validateUniquenessRes.isLeft()) { - return Either.left(!validateUniquenessRes.left().value()); - } - return validateUniquenessRes; - } - - public Either dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { - return nodeTemplateOperation.dissociateResourceInstances(componentId, requirementDef); - } - - /** - * Allows to get fulfilled requirement by relation and received predicate - */ - public Either getFulfilledRequirementByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { - return nodeTemplateOperation.getFulfilledRequirementByRelation(componentId, instanceId, relation, predicate); - } - - /** - * Allows to get fulfilled capability by relation and received predicate - */ - public Either getFulfilledCapabilityByRelation(String componentId, String instanceId, RequirementCapabilityRelDef relation, BiPredicate predicate) { - return nodeTemplateOperation.getFulfilledCapabilityByRelation(componentId, instanceId, relation, predicate); - } - - public StorageOperationStatus associateResourceInstances(String componentId, List relations) { - Either, StorageOperationStatus> status = nodeTemplateOperation.associateResourceInstances(componentId, relations); - if (status.isRight()) { - return status.right().value(); - } - return StorageOperationStatus.OK; - } - - protected Either validateToscaResourceNameUniqueness(String name) { - - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, name); - - Either, TitanOperationStatus> resources = titanDao.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata); - - if (resources.isRight() && resources.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("failed to get resources from graph with property name: {}", name); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(resources.right().value())); - } - List resourceList = (resources.isLeft() ? resources.left().value() : null); - if (isNotEmpty(resourceList)) { - if (log.isDebugEnabled()) { - StringBuilder builder = new StringBuilder(); - for (GraphVertex resourceData : resourceList) { - builder.append(resourceData.getUniqueId() + "|"); - } - log.debug("resources with property name:{} exists in graph. found {}", name, builder); - } - return Either.left(false); - } else { - log.debug("resources with property name:{} does not exists in graph", name); - return Either.left(true); - } - - } - - // region - Component Update - - public Either overrideComponent(Resource newComponent, Resource oldComponent) { - - copyArtifactsToNewComponent(newComponent, oldComponent); - - Either componentVEither = titanDao.getVertexById(oldComponent.getUniqueId(), JsonParseFlagEnum.NoParse); - if (componentVEither.isRight()) { - log.debug("Falied to fetch component {} error {}", oldComponent.getUniqueId(), componentVEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(componentVEither.right().value())); - } - GraphVertex componentv = componentVEither.left().value(); - Either parentVertexEither = titanDao.getParentVertex(componentv, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse); - if (parentVertexEither.isRight() && parentVertexEither.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("Falied to fetch parent version for component {} error {}", oldComponent.getUniqueId(), parentVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentVertexEither.right().value())); - } - - Either deleteToscaComponent = deleteToscaElement(componentv); - if (deleteToscaComponent.isRight()) { - log.debug("Falied to remove old component {} error {}", oldComponent.getUniqueId(), deleteToscaComponent.right().value()); - return Either.right(deleteToscaComponent.right().value()); - } - Either createToscaComponent = createToscaComponent(newComponent); - if (createToscaComponent.isRight()) { - log.debug("Falied to create tosca element component {} error {}", newComponent.getUniqueId(), createToscaComponent.right().value()); - return Either.right(createToscaComponent.right().value()); - } - Resource newElement = createToscaComponent.left().value(); - Either newVersionEither = titanDao.getVertexById(newElement.getUniqueId(), JsonParseFlagEnum.NoParse); - if (newVersionEither.isRight()) { - log.debug("Falied to fetch new tosca element component {} error {}", newComponent.getUniqueId(), newVersionEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(newVersionEither.right().value())); - } - if (parentVertexEither.isLeft()) { - GraphVertex previousVersionV = parentVertexEither.left().value(); - TitanOperationStatus createEdge = titanDao.createEdge(previousVersionV, newVersionEither.left().value(), EdgeLabelEnum.VERSION, null); - if (createEdge != TitanOperationStatus.OK) { - log.debug("Falied to associate to previous version {} new version {} error {}", previousVersionV.getUniqueId(), newVersionEither.right().value(), createEdge); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdge)); - } - } - return Either.left(newElement); - } - - void copyArtifactsToNewComponent(Resource newComponent, Resource oldComponent) { - // TODO - check if required - Map toscaArtifacts = oldComponent.getToscaArtifacts(); - if (toscaArtifacts != null && !toscaArtifacts.isEmpty()) { - toscaArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); - } - newComponent.setToscaArtifacts(toscaArtifacts); - - Map artifacts = oldComponent.getArtifacts(); - if (artifacts != null && !artifacts.isEmpty()) { - artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); - } - newComponent.setArtifacts(artifacts); - - Map depArtifacts = oldComponent.getDeploymentArtifacts(); - if (depArtifacts != null && !depArtifacts.isEmpty()) { - depArtifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE)); - } - newComponent.setDeploymentArtifacts(depArtifacts); - - newComponent.setGroups(oldComponent.getGroups()); - newComponent.setLastUpdateDate(null); - newComponent.setHighestVersion(true); - } - - public Either updateToscaElement(T componentToUpdate) { - return updateToscaElement(componentToUpdate, new ComponentParametersView()); - } - - public Either updateToscaElement(T componentToUpdate, ComponentParametersView filterResult) { - String componentId = componentToUpdate.getUniqueId(); - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } - GraphVertex elementV = getVertexEither.left().value(); - ToscaElementOperation toscaElementOperation = getToscaElementOperation(elementV); - - ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(componentToUpdate); - Either updateToscaElement = toscaElementOperation.updateToscaElement(toscaElementToUpdate, elementV, filterResult); - if (updateToscaElement.isRight()) { - log.debug("Failed to update tosca element {} error {}", componentId, updateToscaElement.right().value()); - return Either.right(updateToscaElement.right().value()); - } - return Either.left(ModelConverter.convertFromToscaElement(updateToscaElement.left().value())); - } - - private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag) { - return getLatestByName(property, nodeName, parseFlag, new ComponentParametersView()); - } - - private Either getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag, ComponentParametersView filter) { - Either result; - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - - propertiesToMatch.put(property, nodeName); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - Either, TitanOperationStatus> highestResources = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, parseFlag); - if (highestResources.isRight()) { - TitanOperationStatus status = highestResources.right().value(); - log.debug("failed to find resource with name {}. status={} ", nodeName, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - - List resources = highestResources.left().value(); - double version = 0.0; - GraphVertex highestResource = null; - for (GraphVertex vertex : resources) { - Object versionObj = vertex.getMetadataProperty(GraphPropertyEnum.VERSION); - double resourceVersion = Double.parseDouble((String) versionObj); - if (resourceVersion > version) { - version = resourceVersion; - highestResource = vertex; - } - } - return getToscaElementByOperation(highestResource, filter); - } - - // endregion - // region - Component Get By .. - private Either getLatestByName(GraphPropertyEnum property, String nodeName) { - return getLatestByName(property, nodeName, JsonParseFlagEnum.ParseMetadata); - } - - public Either, StorageOperationStatus> getBySystemName(ComponentTypeEnum componentType, String systemName) { - - Either, StorageOperationStatus> result = null; - Either getComponentRes; - List components = new ArrayList<>(); - List componentVertices; - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - - propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, systemName); - if (componentType != null) - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - Either, TitanOperationStatus> getComponentsRes = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); - if (getComponentsRes.isRight()) { - TitanOperationStatus status = getComponentsRes.right().value(); - log.debug("Failed to fetch the component with system name {}. Status is {} ", systemName, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - componentVertices = getComponentsRes.left().value(); - for (GraphVertex componentVertex : componentVertices) { - getComponentRes = getToscaElementByOperation(componentVertex); - if (getComponentRes.isRight()) { - log.debug("Failed to get the component {}. Status is {} ", componentVertex.getJsonMetadataField(JsonPresentationFields.NAME), getComponentRes.right().value()); - result = Either.right(getComponentRes.right().value()); - break; - } - T componentBySystemName = getComponentRes.left().value(); - log.debug("Found component, id: {}", componentBySystemName.getUniqueId()); - components.add(componentBySystemName); - } - } - if (result == null) { - result = Either.left(components); - } - return result; - } - - public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version) { - return getComponentByNameAndVersion(componentType, name, version, JsonParseFlagEnum.ParseAll); - } - - public Either getComponentByNameAndVersion(ComponentTypeEnum componentType, String name, String version, JsonParseFlagEnum parseFlag) { - Either result; - - Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); - Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); - - hasProperties.put(GraphPropertyEnum.NAME, name); - hasProperties.put(GraphPropertyEnum.VERSION, version); - hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); - if (componentType != null) { - hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - } - Either, TitanOperationStatus> getResourceRes = titanDao.getByCriteria(null, hasProperties, hasNotProperties, parseFlag); - if (getResourceRes.isRight()) { - TitanOperationStatus status = getResourceRes.right().value(); - log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - return getToscaElementByOperation(getResourceRes.left().value().get(0)); - } - - public Either, StorageOperationStatus> getCatalogOrArchiveComponents(boolean isCatalog, List excludeTypes) { - List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) - .collect(Collectors.toList()); - return topologyTemplateOperation.getElementCatalogData(isCatalog, excludedResourceTypes); - } - - // endregion - public Either, StorageOperationStatus> getCatalogComponents(ComponentTypeEnum componentType, List excludeTypes, boolean isHighestVersions) { - List components = new ArrayList<>(); - Either, StorageOperationStatus> catalogDataResult; - List toscaElements = new ArrayList<>(); - List excludedResourceTypes = Optional.ofNullable(excludeTypes).orElse(Collections.emptyList()).stream().filter(type -> !type.equals(OriginTypeEnum.SERVICE)).map(type -> ResourceTypeEnum.getTypeByName(type.name())) - .collect(Collectors.toList()); - - switch (componentType) { - case RESOURCE: - catalogDataResult = nodeTypeOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludedResourceTypes, isHighestVersions); - if (catalogDataResult.isRight()) { - return Either.right(catalogDataResult.right().value()); - } - toscaElements = catalogDataResult.left().value(); - break; - case SERVICE: - if (excludeTypes != null && excludeTypes.contains(OriginTypeEnum.SERVICE)) { - break; - } - catalogDataResult = topologyTemplateOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, isHighestVersions); - if (catalogDataResult.isRight()) { - return Either.right(catalogDataResult.right().value()); - } - toscaElements = catalogDataResult.left().value(); - break; - default: - log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); - return Either.right(StorageOperationStatus.BAD_REQUEST); - } - toscaElements.forEach(te -> { - T component = ModelConverter.convertFromToscaElement(te); - components.add(component); - }); - return Either.left(components); - } - - public Either, StorageOperationStatus> deleteMarkedElements(ComponentTypeEnum componentType) { - Either, StorageOperationStatus> allComponentsMarkedForDeletion; - switch (componentType) { - case RESOURCE: - allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); - break; - case SERVICE: - case PRODUCT: - allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); - break; - default: - log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); - return Either.right(StorageOperationStatus.BAD_REQUEST); - } - if (allComponentsMarkedForDeletion.isRight()) { - return Either.right(allComponentsMarkedForDeletion.right().value()); - } - List allMarked = allComponentsMarkedForDeletion.left().value(); - return Either.left(checkIfInUseAndDelete(allMarked)); - } - - private List checkIfInUseAndDelete(List allMarked) { - final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); - List deleted = new ArrayList<>(); - - for (GraphVertex elementV : allMarked) { - boolean isAllowedToDelete = true; - - for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { - Either belongingEdgeByCriteria = titanDao.getBelongingEdgeByCriteria(elementV, edgeLabelEnum, null); - if (belongingEdgeByCriteria.isLeft()){ - log.debug("Marked element {} in use. don't delete it", elementV.getUniqueId()); - isAllowedToDelete = false; - break; - } - } - - if (isAllowedToDelete) { - Either deleteToscaElement = deleteToscaElement(elementV); - if (deleteToscaElement.isRight()) { - log.debug("Failed to delete marked element UniqueID {}, Name {}, error {}", elementV.getUniqueId(), elementV.getMetadataProperties().get(GraphPropertyEnum.NAME), deleteToscaElement.right().value()); - continue; - } - deleted.add(elementV.getUniqueId()); - } - } - return deleted; - } - - public Either, StorageOperationStatus> getAllComponentsMarkedForDeletion(ComponentTypeEnum componentType) { - Either, StorageOperationStatus> allComponentsMarkedForDeletion; - switch (componentType) { - case RESOURCE: - allComponentsMarkedForDeletion = nodeTypeOperation.getAllComponentsMarkedForDeletion(componentType); - break; - case SERVICE: - case PRODUCT: - allComponentsMarkedForDeletion = topologyTemplateOperation.getAllComponentsMarkedForDeletion(componentType); - break; - default: - log.debug(NOT_SUPPORTED_COMPONENT_TYPE, componentType); - return Either.right(StorageOperationStatus.BAD_REQUEST); - } - if (allComponentsMarkedForDeletion.isRight()) { - return Either.right(allComponentsMarkedForDeletion.right().value()); - } - return Either.left(allComponentsMarkedForDeletion.left().value().stream().map(GraphVertex::getUniqueId).collect(Collectors.toList())); - } - - // region - Component Update - public Either, StorageOperationStatus> addComponentInstanceToTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance, boolean allowDeleted, User user) { - - Either, StorageOperationStatus> result = null; - Either updateContainerComponentRes = null; - if (StringUtils.isEmpty(componentInstance.getIcon())) { - componentInstance.setIcon(origComponent.getIcon()); - } - String nameToFindForCounter = componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy ? componentInstance.getSourceModelName() + PROXY_SUFFIX : origComponent.getName(); - String nextComponentInstanceCounter = getNextComponentInstanceCounter(containerComponent, nameToFindForCounter); - Either, StorageOperationStatus> addResult = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), - ModelConverter.convertToToscaElement(origComponent), nextComponentInstanceCounter, componentInstance, allowDeleted, user); - - if (addResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the component instance {} to container component {}. ", componentInstance.getName(), containerComponent.getName()); - result = Either.right(addResult.right().value()); - } - if (result == null) { - updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponent.getUniqueId()); - if (updateContainerComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", containerComponent.getName(), componentInstance.getName()); - result = Either.right(updateContainerComponentRes.right().value()); - } - } - if (result == null) { - Component updatedComponent = ModelConverter.convertFromToscaElement(updateContainerComponentRes.left().value()); - String createdInstanceId = addResult.left().value().getRight(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been added to container component {}. ", createdInstanceId, updatedComponent.getName()); - result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); - } - return result; - } - - public StorageOperationStatus associateComponentInstancesToComponent(Component containerComponent, Map resourcesInstancesMap, boolean allowDeleted) { - - StorageOperationStatus result = null; - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Going to add component instances to component {}", containerComponent.getUniqueId()); - - Either metadataVertex = titanDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.ParseAll); - if (metadataVertex.isRight()) { - TitanOperationStatus status = metadataVertex.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; - } - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); - } - if (result == null) { - result = nodeTemplateOperation.associateComponentInstancesToComponent(containerComponent, resourcesInstancesMap, metadataVertex.left().value(), allowDeleted); - } - return result; - } - - public Either, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, Component origComponent, ComponentInstance componentInstance) { - - Either, StorageOperationStatus> result = null; - - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); - componentInstance.setIcon(origComponent.getIcon()); - Either, StorageOperationStatus> updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), - ModelConverter.convertToToscaElement(origComponent), componentInstance); - if (updateResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata of the component instance {} belonging to container component {}. ", componentInstance.getName(), containerComponent.getName()); - result = Either.right(updateResult.right().value()); - } - if (result == null) { - Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); - String createdInstanceId = updateResult.left().value().getRight(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata of the component instance {} has been updated to container component {}. ", createdInstanceId, updatedComponent.getName()); - result = Either.left(new ImmutablePair<>(updatedComponent, createdInstanceId)); - } - return result; - } - - public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent) { - return updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, new ComponentParametersView()); - } - - public Either updateComponentInstanceMetadataOfTopologyTemplate(Component containerComponent, ComponentParametersView filter) { - - Either result = null; - - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update the metadata belonging to container component {}. ", containerComponent.getName()); - - Either updateResult = nodeTemplateOperation.updateComponentInstanceMetadataOfTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), filter); - if (updateResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the metadata belonging to container component {}. ", containerComponent.getName()); - result = Either.right(updateResult.right().value()); - } - if (result == null) { - Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value()); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The metadata has been updated to container component {}. ", updatedComponent.getName()); - result = Either.left(updatedComponent); - } - return result; - } - // endregion - - public Either, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(Component containerComponent, String resourceInstanceId) { - - Either, StorageOperationStatus> result = null; - - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); - - Either, StorageOperationStatus> updateResult = nodeTemplateOperation.deleteComponentInstanceFromTopologyTemplate(ModelConverter.convertToToscaElement(containerComponent), resourceInstanceId); - if (updateResult.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete the component instance {} belonging to container component {}. ", resourceInstanceId, containerComponent.getName()); - result = Either.right(updateResult.right().value()); - } - if (result == null) { - Component updatedComponent = ModelConverter.convertFromToscaElement(updateResult.left().value().getLeft()); - String deletedInstanceId = updateResult.left().value().getRight(); - CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "The component instance {} has been deleted from container component {}. ", deletedInstanceId, updatedComponent.getName()); - result = Either.left(new ImmutablePair<>(updatedComponent, deletedInstanceId)); - } - return result; - } - - private String getNextComponentInstanceCounter(Component containerComponent, String originResourceName) { - Integer nextCounter = 0; - if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstances())) { - String normalizedName = ValidationUtils.normalizeComponentInstanceName(originResourceName); - Integer maxCounter = getMaxCounterFromNamesAndIds(containerComponent, normalizedName); - if (maxCounter != null) { - nextCounter = maxCounter + 1; - } - } - return nextCounter.toString(); - } - - /** - * @return max counter of component instance Id's, null if not found - */ - private Integer getMaxCounterFromNamesAndIds(Component containerComponent, String normalizedName) { - List countersInNames = containerComponent.getComponentInstances().stream() - .filter(ci -> ci.getNormalizedName() != null && ci.getNormalizedName().startsWith(normalizedName)) - .map(ci -> ci.getNormalizedName().split(normalizedName)[1]) - .collect(Collectors.toList()); - List countersInIds = containerComponent.getComponentInstances().stream() - .filter(ci -> ci.getUniqueId() != null && ci.getUniqueId().contains(normalizedName)) - .map(ci -> ci.getUniqueId().split(normalizedName)[1]) - .collect(Collectors.toList()); - List namesAndIdsList = new ArrayList<>(countersInNames); - namesAndIdsList.addAll(countersInIds); - return getMaxInteger(namesAndIdsList); - } - - private Integer getMaxInteger(List counters) { - Integer maxCounter = 0; - Integer currCounter = null; - for (String counter : counters) { - try { - currCounter = Integer.parseInt(counter); - if (maxCounter < currCounter) { - maxCounter = currCounter; - } - } catch (NumberFormatException e) { - continue; - } - } - return currCounter == null ? null : maxCounter; - } - - public Either associateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) { - return nodeTemplateOperation.associateResourceInstances(componentId, requirementDef); - - } - - public Either, StorageOperationStatus> createAndAssociateInputs(Map inputs, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDataDefinition(e.getValue()))); - - StorageOperationStatus status = topologyTemplateOperation.associateInputsToComponent(vertex, inputsMap, componentId); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - List inputsResList = null; - if (inputsMap != null && !inputsMap.isEmpty()) { - inputsResList = inputsMap.values().stream() - .map(InputDefinition::new) - .collect(Collectors.toList()); - } - return Either.left(inputsResList); - } - return Either.right(status); - - } - - public Either, StorageOperationStatus> addInputsToComponent(Map inputs, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDefinition(e.getValue()))); - - StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsMap, JsonPresentationFields.NAME); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - List inputsResList = null; - if (inputsMap != null && !inputsMap.isEmpty()) { - inputsResList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList()); - } - return Either.left(inputsResList); - } - return Either.right(status); - - } - - /** - * Add data types into a Component. - * - * @param dataTypes datatypes to be added. the key should be each name of data type. - * @param componentId unique ID of Component. - * @return list of data types. - */ - public Either, StorageOperationStatus> addDataTypesToComponent(Map dataTypes, String componentId) { - - log.trace("#addDataTypesToComponent - enter, componentId={}", componentId); - - /* get component vertex */ - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - /* not found / error */ - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } - GraphVertex vertex = getVertexEither.left().value(); - log.trace("#addDataTypesToComponent - get vertex ok"); - - // convert DataTypeDefinition to DataTypeDataDefinition - Map dataTypeDataMap = dataTypes.entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, e -> convertDataTypeToDataTypeData(e.getValue()))); - - // add datatype(s) to the Component. - // if child vertex does not exist, it will be created. - StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, - EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeDataMap, JsonPresentationFields.NAME); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - List inputsResList = null; - if (!dataTypes.isEmpty()) { - inputsResList = new ArrayList<>(dataTypes.values()); - } - return Either.left(inputsResList); - } - - log.trace("#addDataTypesToComponent - leave"); - return Either.right(status); - } - - private DataTypeDataDefinition convertDataTypeToDataTypeData(DataTypeDefinition dataType) { - DataTypeDataDefinition dataTypeData = new DataTypeDataDefinition(dataType); - if (CollectionUtils.isNotEmpty(dataType.getProperties())) { - List propertyDataList = dataType.getProperties().stream() - .map(PropertyDataDefinition::new).collect(Collectors.toList()); - dataTypeData.setPropertiesData(propertyDataList); - } - - // if "derivedFrom" data_type exists, copy the name to "derivedFromName" - if (dataType.getDerivedFrom() != null && StringUtils.isNotEmpty(dataType.getDerivedFrom().getName())) { - // if names are different, log it - if (!StringUtils.equals(dataTypeData.getDerivedFromName(), dataType.getDerivedFrom().getName())) { - log.debug("#convertDataTypeToDataTypeData - derivedFromName(={}) overwritten by derivedFrom.name(={})", - dataType.getDerivedFromName(), dataType.getDerivedFrom().getName()); - } - dataTypeData.setDerivedFromName(dataType.getDerivedFrom().getName()); - } - - // supply "name" field to toscaPresentationValue in each datatype object for DAO operations - dataTypeData.setToscaPresentationValue(JsonPresentationFields.NAME, dataType.getName()); - return dataTypeData; - } - - - public Either, StorageOperationStatus> getComponentInputs(String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug("Couldn't fetch component with and unique id {}, error: {}", componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - - Either toscaElement = - topologyTemplateOperation.getToscaElement(componentId); - if(toscaElement.isRight()) { - return Either.right(toscaElement.right().value()); - } - - TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement.left().value(); - - Map inputsMap = topologyTemplate.getInputs(); - - List inputs = new ArrayList<>(); - if(MapUtils.isNotEmpty(inputsMap)) { - inputs = - inputsMap.values().stream().map(p -> new InputDefinition(p)).collect(Collectors.toList()); - } - - return Either.left(inputs); - } - - public Either, StorageOperationStatus> updateInputsToComponent(List inputs, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - - GraphVertex vertex = getVertexEither.left().value(); - List inputsAsDataDef = inputs.stream().map(PropertyDataDefinition::new).collect(Collectors.toList()); - - StorageOperationStatus status = topologyTemplateOperation.updateToscaDataOfToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsAsDataDef, JsonPresentationFields.NAME); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - List inputsResList = null; - if (inputsAsDataDef != null && !inputsAsDataDef.isEmpty()) { - inputsResList = inputsAsDataDef.stream().map(InputDefinition::new).collect(Collectors.toList()); - } - return Either.left(inputsResList); - } - return Either.right(status); - - } - - // region - ComponentInstance - public Either>, StorageOperationStatus> associateComponentInstancePropertiesToComponent(Map> instProperties, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map instPropsMap = new HashMap<>(); - if (instProperties != null) { - - MapPropertiesDataDefinition propertiesMap; - for (Entry> entry : instProperties.entrySet()) { - propertiesMap = new MapPropertiesDataDefinition(); - - propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); - - instPropsMap.put(entry.getKey(), propertiesMap); - } - } - - StorageOperationStatus status = topologyTemplateOperation.associateInstPropertiesToComponent(vertex, instPropsMap); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - return Either.left(instProperties); - } - return Either.right(status); - - } - - /** - * saves the instInputs as the updated instance inputs of the component container in DB - */ - public Either>, StorageOperationStatus> updateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { - if (instInputs == null || instInputs.isEmpty()) { - return Either.left(instInputs); - } - StorageOperationStatus status; - for (Entry> inputsPerIntance : instInputs.entrySet()) { - List toscaDataListPerInst = inputsPerIntance.getValue(); - List pathKeysPerInst = new ArrayList<>(); - pathKeysPerInst.add(inputsPerIntance.getKey()); - status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", inputsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_INPUTS, status); - return Either.right(status); - } - } - - return Either.left(instInputs); - } - - /** - * saves the instProps as the updated instance properties of the component container in DB - */ - public Either>, StorageOperationStatus> updateComponentInstancePropsToComponent(Map> instProps, String componentId) { - if (instProps == null || instProps.isEmpty()) { - return Either.left(instProps); - } - StorageOperationStatus status; - for (Entry> propsPerIntance : instProps.entrySet()) { - List toscaDataListPerInst = propsPerIntance.getValue(); - List pathKeysPerInst = new ArrayList<>(); - pathKeysPerInst.add(propsPerIntance.getKey()); - status = topologyTemplateOperation.updateToscaDataDeepElementsOfToscaElement(componentId, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update component instance inputs for instance {} in component {} edge type {} error {}", propsPerIntance.getKey(), componentId, EdgeLabelEnum.INST_PROPERTIES, status); - return Either.right(status); - } - } - - return Either.left(instProps); - } - - public Either>, StorageOperationStatus> associateComponentInstanceInputsToComponent(Map> instInputs, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - GraphVertex vertex = getVertexEither.left().value(); - Map instPropsMap = new HashMap<>(); - if (instInputs != null) { - - MapPropertiesDataDefinition propertiesMap; - for (Entry> entry : instInputs.entrySet()) { - propertiesMap = new MapPropertiesDataDefinition(); - - propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); - - instPropsMap.put(entry.getKey(), propertiesMap); - } - } - - StorageOperationStatus status = topologyTemplateOperation.associateInstInputsToComponent(vertex, instPropsMap); - - if (StorageOperationStatus.OK == status) { - log.debug(COMPONENT_CREATED_SUCCESSFULLY); - return Either.left(instInputs); - } - return Either.right(status); - - } - - public Either>, StorageOperationStatus> addComponentInstanceInputsToComponent(Component containerComponent, Map> instProperties) { - requireNonNull(instProperties); - StorageOperationStatus status; - for (Entry> entry : instProperties.entrySet()) { - List props = entry.getValue(); - String componentInstanceId = entry.getKey(); - if (!isEmpty(props)) { - for (ComponentInstanceInput property : props) { - List componentInstancesInputs = containerComponent.getComponentInstancesInputs().get(componentInstanceId); - Optional instanceProperty = componentInstancesInputs.stream() - .filter(p -> p.getName().equals(property.getName())) - .findAny(); - if (instanceProperty.isPresent()) { - status = updateComponentInstanceInput(containerComponent, componentInstanceId, property); - } else { - status = addComponentInstanceInput(containerComponent, componentInstanceId, property); - } - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update instance input {} for instance {} error {} ", property, componentInstanceId, status); - return Either.right(status); - } else { - log.trace("instance input {} for instance {} updated", property, componentInstanceId); - } - } - } - } - return Either.left(instProperties); - } - - public Either>, StorageOperationStatus> addComponentInstancePropertiesToComponent(Component containerComponent, Map> instProperties) { - requireNonNull(instProperties); - for (Entry> entry : instProperties.entrySet()) { - List props = entry.getValue(); - String componentInstanceId = entry.getKey(); - List originalComponentInstProps = - containerComponent.getComponentInstancesProperties().get(componentInstanceId); - Map> containerComponentCapabilities = containerComponent.getCapabilities(); - - if(isEmpty(props)) { - continue; - } - for (ComponentInstanceProperty property : props) { - StorageOperationStatus status = null; - String propertyParentUniqueId = property.getParentUniqueId(); - Optional - capPropDefinition = getPropertyCapability(propertyParentUniqueId, containerComponent); - if(capPropDefinition.isPresent() && MapUtils.isNotEmpty(containerComponentCapabilities)) { - status = populateAndUpdateInstanceCapProperty(containerComponent, componentInstanceId, - containerComponentCapabilities, property, capPropDefinition.get()); - } - if(status == null) { - status = updateOrAddComponentInstanceProperty(containerComponent, componentInstanceId, - originalComponentInstProps, property); - } - if(status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - } - return Either.left(instProperties); - } - - private StorageOperationStatus populateAndUpdateInstanceCapProperty(Component containerComponent, String componentInstanceId, - Map> containerComponentCapabilities, - ComponentInstanceProperty property, - CapabilityDefinition capabilityDefinition) { - List capabilityDefinitions = containerComponentCapabilities.get(capabilityDefinition.getType()); - if(CollectionUtils.isEmpty(capabilityDefinitions)) { - return null; - } - Optional capDefToGetProp = capabilityDefinitions.stream() - .filter(cap -> cap.getUniqueId().equals(capabilityDefinition.getUniqueId()) && cap.getPath().size() == 1).findAny(); - if(capDefToGetProp.isPresent()) { - return updateInstanceCapabilityProperty(containerComponent, componentInstanceId, property, capDefToGetProp.get()); - } - return null; - } - - private static Optional getPropertyCapability(String propertyParentUniqueId, - Component containerComponent) { - - Map> componentCapabilities = containerComponent.getCapabilities(); - if(MapUtils.isEmpty(componentCapabilities)){ - return Optional.empty(); - } - List capabilityDefinitionList = componentCapabilities.values() - .stream().flatMap(Collection::stream).collect(Collectors.toList()); - if(CollectionUtils.isEmpty(capabilityDefinitionList)){ - return Optional.empty(); - } - return capabilityDefinitionList.stream() - .filter(capabilityDefinition -> capabilityDefinition.getUniqueId().equals(propertyParentUniqueId)) - .findAny(); - } - - private StorageOperationStatus updateOrAddComponentInstanceProperty(Component containerComponent, - String componentInstanceId, List originalComponentInstProps, - ComponentInstanceProperty property) - { - StorageOperationStatus status; - // check if the property already exists or not - Optional instanceProperty = originalComponentInstProps.stream() - .filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny(); - if (instanceProperty.isPresent()) { - status = updateComponentInstanceProperty(containerComponent, componentInstanceId, property); - } else { - status = addComponentInstanceProperty(containerComponent, componentInstanceId, property); - } - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update instance property {} for instance {} error {} ", - property, componentInstanceId, status); - } - return status; - } - - public StorageOperationStatus updateInstanceCapabilityProperty(Component containerComponent, String componentInstanceId, - ComponentInstanceProperty property, - CapabilityDefinition capabilityDefinition) { - Optional fetchedCIOptional = containerComponent.getComponentInstanceById(componentInstanceId); - if(!fetchedCIOptional.isPresent()) { - return StorageOperationStatus.GENERAL_ERROR; - } - Either getComponentRes = - getToscaFullElement(fetchedCIOptional.get().getComponentUid()); - if(getComponentRes.isRight()) { - return StorageOperationStatus.GENERAL_ERROR; - } - Optional componentOptional = isNodeServiceProxy(getComponentRes.left().value()); - String propOwner; - if(!componentOptional.isPresent()) { - propOwner = componentInstanceId; - } else { - propOwner = fetchedCIOptional.get().getSourceModelUid(); - } - StorageOperationStatus status; - StringBuffer sb = new StringBuffer(componentInstanceId); - sb.append(ModelConverter.CAP_PROP_DELIM).append(propOwner).append(ModelConverter.CAP_PROP_DELIM) - .append(capabilityDefinition.getType()).append(ModelConverter.CAP_PROP_DELIM).append(capabilityDefinition.getName()); - String capKey = sb.toString(); - status = updateComponentInstanceCapabiltyProperty(containerComponent, componentInstanceId, capKey, property); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to update instance capability property {} for instance {} error {} ", property, - componentInstanceId, status); - return status; - } - return StorageOperationStatus.OK; - } - - private Optional isNodeServiceProxy(Component component) { - if (component.getComponentType().equals(ComponentTypeEnum.SERVICE)) { - return Optional.empty(); - } - Resource resource = (Resource) component; - ResourceTypeEnum resType = resource.getResourceType(); - if(resType.equals(ResourceTypeEnum.ServiceProxy)) { - return Optional.of(component); - } - return Optional.empty(); - } - - public StorageOperationStatus associateDeploymentArtifactsToInstances(Map> instDeploymentArtifacts, String componentId, User user) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map instArtMap = new HashMap<>(); - if (instDeploymentArtifacts != null) { - - MapArtifactDataDefinition artifactsMap; - for (Entry> entry : instDeploymentArtifacts.entrySet()) { - Map artList = entry.getValue(); - Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - artifactsMap = nodeTemplateOperation.prepareInstDeploymentArtifactPerInstance(artifacts, entry.getKey(), user, NodeTemplateOperation.HEAT_VF_ENV_NAME); - - instArtMap.put(entry.getKey(), artifactsMap); - } - } - - return topologyTemplateOperation.associateInstDeploymentArtifactsToComponent(vertex, instArtMap); - - } - - public StorageOperationStatus associateArtifactsToInstances(Map> instArtifacts, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map instArtMap = new HashMap<>(); - if (instArtifacts != null) { - - MapArtifactDataDefinition artifactsMap; - for (Entry> entry : instArtifacts.entrySet()) { - Map artList = entry.getValue(); - Map artifacts = artList.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - artifactsMap = new MapArtifactDataDefinition(artifacts); - - instArtMap.put(entry.getKey(), artifactsMap); - } - } - - return topologyTemplateOperation.associateInstArtifactsToComponent(vertex, instArtMap); - - } - - public StorageOperationStatus associateInstAttributeToComponentToInstances(Map> instArttributes, String componentId) { - - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()); - - } - - GraphVertex vertex = getVertexEither.left().value(); - Map instAttr = new HashMap<>(); - if (instArttributes != null) { - - MapPropertiesDataDefinition attributesMap; - for (Entry> entry : instArttributes.entrySet()) { - attributesMap = new MapPropertiesDataDefinition(); - attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, e -> e))); - instAttr.put(entry.getKey(), attributesMap); - } - } - - return topologyTemplateOperation.associateInstAttributeToComponent(vertex, instAttr); - - } - // endregion - - public StorageOperationStatus associateOrAddCalculatedCapReq(Map>> instCapabilties, Map>> instReg, String componentId) { - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()); - - } - - GraphVertex vertex = getVertexEither.left().value(); - - Map calcRequirements = new HashMap<>(); - - Map calcCapabilty = new HashMap<>(); - Map calculatedCapabilitiesProperties = new HashMap<>(); - if (instCapabilties != null) { - for (Entry>> entry : instCapabilties.entrySet()) { - - Map> caps = entry.getValue(); - Map mapToscaDataDefinition = new HashMap<>(); - for (Entry> instCapability : caps.entrySet()) { - mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))); - } - - ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(entry.getKey()); - MapListCapabilityDataDefinition capMap = nodeTemplateOperation.prepareCalculatedCapabiltyForNodeType(mapToscaDataDefinition, componentInstance); - - MapCapabilityProperty mapCapabilityProperty = ModelConverter.convertToMapOfMapCapabiltyProperties(caps, componentInstance.getUniqueId(), true); - - calcCapabilty.put(entry.getKey().getUniqueId(), capMap); - calculatedCapabilitiesProperties.put(entry.getKey().getUniqueId(), mapCapabilityProperty); - } - } - - if (instReg != null) { - for (Entry>> entry : instReg.entrySet()) { - - Map> req = entry.getValue(); - Map mapToscaDataDefinition = new HashMap<>(); - for (Entry> instReq : req.entrySet()) { - mapToscaDataDefinition.put(instReq.getKey(), new ListRequirementDataDefinition(instReq.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList()))); - } - - MapListRequirementDataDefinition capMap = nodeTemplateOperation.prepareCalculatedRequirementForNodeType(mapToscaDataDefinition, new ComponentInstanceDataDefinition(entry.getKey())); - - calcRequirements.put(entry.getKey().getUniqueId(), capMap); - } - } - - return topologyTemplateOperation.associateOrAddCalcCapReqToComponent(vertex, calcRequirements, calcCapabilty, calculatedCapabilitiesProperties); - } - - private Either, StorageOperationStatus> getLatestVersionNonCheckoutServicesMetadataOnly(Map hasProps, Map hasNotProps) { - List services = new ArrayList<>(); - List states = new ArrayList<>(); - // include props - hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - // exclude props - states.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - hasNotProps.put(GraphPropertyEnum.STATE, states); - hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); - hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); - return fetchServicesByCriteria(services, hasProps, hasNotProps); - } - - private Either, StorageOperationStatus> getLatestVersionNotAbstractToscaElementsMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType, VertexTypeEnum vertexType) { - List services = null; - Map hasProps = new EnumMap<>(GraphPropertyEnum.class); - Map hasNotProps = new EnumMap<>(GraphPropertyEnum.class); - fillPropsMap(hasProps, hasNotProps, internalComponentType, componentTypeEnum, isAbstract, vertexType); - Either, TitanOperationStatus> getRes = titanDao.getByCriteria(vertexType, hasProps, hasNotProps, JsonParseFlagEnum.ParseMetadata); - if (getRes.isRight()) { - if (getRes.right().value().equals(TitanOperationStatus.NOT_FOUND)) { - return Either.left(new ArrayList<>()); - } else { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getRes.right().value())); - } - } - // region -> Fetch non checked-out services - if (internalComponentType != null && internalComponentType.toLowerCase().trim().equals(SERVICE) && VertexTypeEnum.NODE_TYPE == vertexType) { - Either, StorageOperationStatus> result = getLatestVersionNonCheckoutServicesMetadataOnly(new EnumMap<>(GraphPropertyEnum.class), new EnumMap<>(GraphPropertyEnum.class)); - if (result.isRight()) { - log.debug("Failed to fetch services for"); - return Either.right(result.right().value()); - } - services = result.left().value(); - if (log.isTraceEnabled() && isEmpty(services)) - log.trace("No relevant services available"); - } - // endregion - List nonAbstractLatestComponents = new ArrayList<>(); - ComponentParametersView params = new ComponentParametersView(true); - params.setIgnoreAllVersions(false); - for (GraphVertex vertexComponent : getRes.left().value()) { - Either componentRes = topologyTemplateOperation.getLightComponent(vertexComponent, componentTypeEnum, params); - if (componentRes.isRight()) { - log.debug("Failed to fetch light element for {} error {}", vertexComponent.getUniqueId(), componentRes.right().value()); - return Either.right(componentRes.right().value()); - } else { - Component component = ModelConverter.convertFromToscaElement(componentRes.left().value()); - nonAbstractLatestComponents.add(component); - } - } - if (CollectionUtils.isNotEmpty(services)) { - nonAbstractLatestComponents.addAll(services); - } - return Either.left(nonAbstractLatestComponents); - } - - public Either getLatestComponentMetadataByUuid(String componentUuid, JsonParseFlagEnum parseFlag, Boolean isHighest) { - - Either result; - Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); - hasProperties.put(GraphPropertyEnum.UUID, componentUuid); - if (isHighest != null) { - hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); - } - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 - - Either, TitanOperationStatus> getRes = titanDao.getByCriteria(null, hasProperties, propertiesNotToMatch, parseFlag); - if (getRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getRes.right().value())); - } else { - List latestVersionList = getRes.left().value().stream().map(ModelConverter::convertToComponentMetadata).collect(Collectors.toList()); - ComponentMetadataData latestVersion = latestVersionList.size() == 1 ? latestVersionList.get(0) - : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getMetadataDataDefinition().getVersion()), Double.parseDouble(c2.getMetadataDataDefinition().getVersion()))).get(); - result = Either.left(latestVersion); - } - return result; - } - - public Either getComponentMetadata(String componentId) { - Either result; - Either getRes = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); - if (getRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getRes.right().value())); - } else { - ComponentMetadataData componentMetadata = ModelConverter.convertToComponentMetadata(getRes.left().value()); - result = Either.left(componentMetadata); - } - return result; - } - - public Either, StorageOperationStatus> getLatestVersionNotAbstractComponents(boolean isAbstract, ComponentTypeEnum componentTypeEnum, - String internalComponentType, List componentUids) { - - List components = new ArrayList<>(); - if (componentUids == null) { - Either, StorageOperationStatus> componentUidsRes = getComponentUids(isAbstract, componentTypeEnum, internalComponentType); - if (componentUidsRes.isRight()) { - return Either.right(componentUidsRes.right().value()); - } - componentUids = componentUidsRes.left().value(); - } - if (!isEmpty(componentUids)) { - for (String componentUid : componentUids) { - ComponentParametersView componentParametersView = buildComponentViewForNotAbstract(); - if ("vl".equalsIgnoreCase(internalComponentType)) { - componentParametersView.setIgnoreCapabilities(false); - componentParametersView.setIgnoreRequirements(false); - } - Either getToscaElementRes = nodeTemplateOperation.getToscaElementOperation(componentTypeEnum).getLightComponent(componentUid, componentTypeEnum, componentParametersView); - if (getToscaElementRes.isRight()) { - log.debug("Failed to fetch resource for error is {}", getToscaElementRes.right().value()); - return Either.right(getToscaElementRes.right().value()); - } - Component component = ModelConverter.convertFromToscaElement(getToscaElementRes.left().value()); - nullifySomeComponentProperties(component); - components.add(component); - } - } - return Either.left(components); - } - - public void nullifySomeComponentProperties(Component component) { - component.setContactId(null); - component.setCreationDate(null); - component.setCreatorUserId(null); - component.setCreatorFullName(null); - component.setLastUpdateDate(null); - component.setLastUpdaterUserId(null); - component.setLastUpdaterFullName(null); - component.setNormalizedName(null); - } - - private Either, StorageOperationStatus> getComponentUids(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { - - Either, StorageOperationStatus> getToscaElementsRes = getLatestVersionNotAbstractMetadataOnly(isAbstract, componentTypeEnum, internalComponentType); - if (getToscaElementsRes.isRight()) { - return Either.right(getToscaElementsRes.right().value()); - } - List collection = getToscaElementsRes.left().value(); - List componentUids; - if (collection == null) { - componentUids = new ArrayList<>(); - } else { - componentUids = collection.stream() - .map(Component::getUniqueId) - .collect(Collectors.toList()); - } - return Either.left(componentUids); - } - - private ComponentParametersView buildComponentViewForNotAbstract() { - ComponentParametersView componentParametersView = new ComponentParametersView(); - componentParametersView.disableAll(); - componentParametersView.setIgnoreCategories(false); - componentParametersView.setIgnoreAllVersions(false); - return componentParametersView; - } - - public Either validateComponentNameExists(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { - Either result = validateComponentNameUniqueness(name, resourceType, componentType); - if (result.isLeft()) { - result = Either.left(!result.left().value()); - } - return result; - } - - public Either validateComponentNameUniqueness(String name, ResourceTypeEnum resourceType, ComponentTypeEnum componentType) { - VertexTypeEnum vertexType = ModelConverter.isAtomicComponent(resourceType) ? VertexTypeEnum.NODE_TYPE : VertexTypeEnum.TOPOLOGY_TEMPLATE; - String normalizedName = ValidationUtils.normaliseComponentName(name); - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.NORMALIZED_NAME, normalizedName); - properties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - - Either, TitanOperationStatus> vertexEither = titanDao.getByCriteria(vertexType, properties, JsonParseFlagEnum.NoParse); - if (vertexEither.isRight() && vertexEither.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("failed to get vertex from graph with property normalizedName: {}", normalizedName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexEither.right().value())); - } - List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; - if (vertexList != null && !vertexList.isEmpty()) { - return Either.left(false); - } else { - return Either.left(true); - } - } - - private void fillNodeTypePropsMap(Map hasProps, Map hasNotProps, String internalComponentType) { - switch (internalComponentType.toLowerCase()) { - case "vf": - case "cvfc": - hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, Arrays.asList(ResourceTypeEnum.VFCMT.name(), ResourceTypeEnum.Configuration.name())); - break; - case SERVICE: - case "pnf": - case "cr": - hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, Arrays.asList(ResourceTypeEnum.VFC.name(), ResourceTypeEnum.VFCMT.name())); - break; - case "vl": - hasProps.put(GraphPropertyEnum.RESOURCE_TYPE, ResourceTypeEnum.VL.name()); - break; - default: - break; - } - } - - private void fillTopologyTemplatePropsMap(Map hasProps, Map hasNotProps, ComponentTypeEnum componentTypeEnum) { - switch (componentTypeEnum) { - case RESOURCE: - hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - break; - case SERVICE: - hasProps.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - break; - default: - break; - } - hasNotProps.put(GraphPropertyEnum.RESOURCE_TYPE, ResourceTypeEnum.CVFC.name()); - } - - private void fillPropsMap(Map hasProps, Map hasNotProps, String internalComponentType, ComponentTypeEnum componentTypeEnum, boolean isAbstract, VertexTypeEnum internalVertexType) { - hasNotProps.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name()); - - hasNotProps.put(GraphPropertyEnum.IS_DELETED, true); - hasNotProps.put(GraphPropertyEnum.IS_ARCHIVED, true); - hasProps.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - if (VertexTypeEnum.NODE_TYPE == internalVertexType) { - hasProps.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); - if (internalComponentType != null) { - fillNodeTypePropsMap(hasProps, hasNotProps, internalComponentType); - } - } else { - fillTopologyTemplatePropsMap(hasProps, hasNotProps, componentTypeEnum); - } - } - - private List getInternalVertexTypes(ComponentTypeEnum componentTypeEnum, String internalComponentType) { - List internalVertexTypes = new ArrayList<>(); - if (ComponentTypeEnum.RESOURCE == componentTypeEnum) { - internalVertexTypes.add(VertexTypeEnum.NODE_TYPE); - } - if (ComponentTypeEnum.SERVICE == componentTypeEnum || SERVICE.equalsIgnoreCase(internalComponentType)) { - internalVertexTypes.add(VertexTypeEnum.TOPOLOGY_TEMPLATE); - } - return internalVertexTypes; - } - - public Either, StorageOperationStatus> getLatestVersionNotAbstractMetadataOnly(boolean isAbstract, ComponentTypeEnum componentTypeEnum, String internalComponentType) { - List internalVertexTypes = getInternalVertexTypes(componentTypeEnum, internalComponentType); - List result = new ArrayList<>(); - for (VertexTypeEnum vertexType : internalVertexTypes) { - Either, StorageOperationStatus> listByVertexType = getLatestVersionNotAbstractToscaElementsMetadataOnly(isAbstract, componentTypeEnum, internalComponentType, vertexType); - if (listByVertexType.isRight()) { - return listByVertexType; - } - result.addAll(listByVertexType.left().value()); - } - return Either.left(result); - - } - - private Either, StorageOperationStatus> getLatestComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - if (additionalPropertiesToMatch != null) { - propertiesToMatch.putAll(additionalPropertiesToMatch); - } - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - return getComponentListByUuid(componentUuid, propertiesToMatch); - } - - public Either getComponentByUuidAndVersion(String componentUuid, String version) { - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - - propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); - propertiesToMatch.put(GraphPropertyEnum.VERSION, version); - - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - Either, TitanOperationStatus> vertexEither = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); - if (vertexEither.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexEither.right().value())); - } - - List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; - if (vertexList == null || vertexList.isEmpty() || vertexList.size() > 1) { - return Either.right(StorageOperationStatus.NOT_FOUND); - } - - return getToscaElementByOperation(vertexList.get(0)); - } - - public Either, StorageOperationStatus> getComponentListByUuid(String componentUuid, Map additionalPropertiesToMatch) { - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - - if (additionalPropertiesToMatch != null) { - propertiesToMatch.putAll(additionalPropertiesToMatch); - } - - propertiesToMatch.put(GraphPropertyEnum.UUID, componentUuid); - - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - propertiesNotToMatch.put(GraphPropertyEnum.IS_ARCHIVED, true); //US382674, US382683 - - Either, TitanOperationStatus> vertexEither = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); - - if (vertexEither.isRight()) { - log.debug("Couldn't fetch metadata for component with uuid {}, error: {}", componentUuid, vertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexEither.right().value())); - } - List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; - - if (vertexList == null || vertexList.isEmpty()) { - log.debug("Component with uuid {} was not found", componentUuid); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - - ArrayList latestComponents = new ArrayList<>(); - for (GraphVertex vertex : vertexList) { - Either toscaElementByOperation = getToscaElementByOperation(vertex); - - if (toscaElementByOperation.isRight()) { - log.debug("Could not fetch the following Component by UUID {}", vertex.getUniqueId()); - return Either.right(toscaElementByOperation.right().value()); - } - - latestComponents.add(toscaElementByOperation.left().value()); - } - - if (latestComponents.size() > 1) { - for (Component component : latestComponents) { - if (component.isHighestVersion()) { - LinkedList highestComponent = new LinkedList<>(); - highestComponent.add(component); - return Either.left(highestComponent); - } - } - } - - return Either.left(latestComponents); - } - - public Either getLatestServiceByUuid(String serviceUuid) { - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - return getLatestComponentByUuid(serviceUuid, propertiesToMatch); - } - - public Either getLatestComponentByUuid(String componentUuid) { - return getLatestComponentByUuid(componentUuid, null); - } - - public Either getLatestComponentByUuid(String componentUuid, Map propertiesToMatch) { - - Either, StorageOperationStatus> latestVersionListEither = getLatestComponentListByUuid(componentUuid, propertiesToMatch); - - if (latestVersionListEither.isRight()) { - return Either.right(latestVersionListEither.right().value()); - } - - List latestVersionList = latestVersionListEither.left().value(); - - if (latestVersionList.isEmpty()) { - return Either.right(StorageOperationStatus.NOT_FOUND); - } - Component component = latestVersionList.size() == 1 ? latestVersionList.get(0) : latestVersionList.stream().max((c1, c2) -> Double.compare(Double.parseDouble(c1.getVersion()), Double.parseDouble(c2.getVersion()))).get(); - - return Either.left(component); - } - - public Either, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract, Boolean isHighest) { - - List resources = new ArrayList<>(); - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - - propertiesToMatch.put(GraphPropertyEnum.IS_ABSTRACT, isAbstract); - if (isHighest != null) { - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, isHighest); - } - propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - Either, TitanOperationStatus> getResourcesRes = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); - - if (getResourcesRes.isRight()) { - log.debug("Failed to fetch all certified resources. Status is {}", getResourcesRes.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getResourcesRes.right().value())); - } - List resourceVerticies = getResourcesRes.left().value(); - for (GraphVertex resourceV : resourceVerticies) { - Either getResourceRes = getToscaElement(resourceV); - if (getResourceRes.isRight()) { - return Either.right(getResourceRes.right().value()); - } - resources.add(getResourceRes.left().value()); - } - return Either.left(resources); - } - - public Either getLatestByNameAndVersion(String name, String version, JsonParseFlagEnum parseFlag) { - Either result; - - Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); - Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); - - hasProperties.put(GraphPropertyEnum.NAME, name); - hasProperties.put(GraphPropertyEnum.VERSION, version); - hasProperties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - - hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); - - Either, TitanOperationStatus> getResourceRes = titanDao.getByCriteria(null, hasProperties, hasNotProperties, parseFlag); - if (getResourceRes.isRight()) { - TitanOperationStatus status = getResourceRes.right().value(); - log.debug("failed to find resource with name {}, version {}. Status is {} ", name, version, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - return result; - } - return getToscaElementByOperation(getResourceRes.left().value().get(0)); - } - - public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName) { - return getLatestComponentByCsarOrName(componentType, csarUUID, systemName, JsonParseFlagEnum.ParseAll); - } - - public Either getLatestComponentByCsarOrName(ComponentTypeEnum componentType, String csarUUID, String systemName, JsonParseFlagEnum parseFlag) { - Map props = new EnumMap<>(GraphPropertyEnum.class); - Map propsHasNot = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.CSAR_UUID, csarUUID); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - if (componentType != null) { - props.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - } - propsHasNot.put(GraphPropertyEnum.IS_DELETED, true); - - GraphVertex resourceMetadataData = null; - List resourceMetadataDataList = null; - Either, TitanOperationStatus> byCsar = titanDao.getByCriteria(null, props, propsHasNot, JsonParseFlagEnum.ParseMetadata); - if (byCsar.isRight()) { - if (TitanOperationStatus.NOT_FOUND == byCsar.right().value()) { - // Fix Defect DE256036 - if (StringUtils.isEmpty(systemName)) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.NOT_FOUND)); - } - - props.clear(); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - props.put(GraphPropertyEnum.SYSTEM_NAME, systemName); - Either, TitanOperationStatus> bySystemname = titanDao.getByCriteria(null, props, JsonParseFlagEnum.ParseMetadata); - if (bySystemname.isRight()) { - log.debug("getLatestResourceByCsarOrName - Failed to find by system name {} error {} ", systemName, bySystemname.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(bySystemname.right().value())); - } - if (bySystemname.left().value().size() > 2) { - log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) must return only 2 latest version, but was returned - {}", bySystemname.left().value().size()); - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - resourceMetadataDataList = bySystemname.left().value(); - if (resourceMetadataDataList.size() == 1) { - resourceMetadataData = resourceMetadataDataList.get(0); - } else { - for (GraphVertex curResource : resourceMetadataDataList) { - if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { - resourceMetadataData = curResource; - break; - } - } - } - if (resourceMetadataData == null) { - log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) returned 2 latest CERTIFIED versions"); - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - if (resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID) != null && !((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID)).equals(csarUUID)) { - log.debug("getLatestResourceByCsarOrName - same system name {} but different csarUUID. exist {} and new {} ", systemName, resourceMetadataData.getJsonMetadataField(JsonPresentationFields.CSAR_UUID), csarUUID); - // correct error will be returned from create flow. with all - // correct audit records!!!!! - return Either.right(StorageOperationStatus.NOT_FOUND); - } - return getToscaElement((String) resourceMetadataData.getUniqueId()); - } - } else { - resourceMetadataDataList = byCsar.left().value(); - if (resourceMetadataDataList.size() > 2) { - log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) must return only 2 latest version, but was returned - {}", byCsar.left().value().size()); - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - if (resourceMetadataDataList.size() == 1) { - resourceMetadataData = resourceMetadataDataList.get(0); - } else { - for (GraphVertex curResource : resourceMetadataDataList) { - if (!((String) curResource.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)).equals("CERTIFIED")) { - resourceMetadataData = curResource; - break; - } - } - } - if (resourceMetadataData == null) { - log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) returned 2 latest CERTIFIED versions"); - return Either.right(StorageOperationStatus.GENERAL_ERROR); - } - return getToscaElement((String) resourceMetadataData.getJsonMetadataField(JsonPresentationFields.UNIQUE_ID), parseFlag); - } - return null; - } - - public Either validateToscaResourceNameExtends(String templateNameCurrent, String templateNameExtends) { - - String currentTemplateNameChecked = templateNameExtends; - - while (currentTemplateNameChecked != null && !currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) { - Either latestByToscaResourceName = getLatestByToscaResourceName(currentTemplateNameChecked); - - if (latestByToscaResourceName.isRight()) { - return latestByToscaResourceName.right().value() == StorageOperationStatus.NOT_FOUND ? Either.left(false) : Either.right(latestByToscaResourceName.right().value()); - } - - Resource value = latestByToscaResourceName.left().value(); - - if (value.getDerivedFrom() != null) { - currentTemplateNameChecked = value.getDerivedFrom().get(0); - } else { - currentTemplateNameChecked = null; - } - } - - return (currentTemplateNameChecked != null && currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) ? Either.left(true) : Either.left(false); - } - - public Either, StorageOperationStatus> fetchMetaDataByResourceType(String resourceType, ComponentParametersView filterBy) { - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.RESOURCE_TYPE, resourceType); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - Map propsHasNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propsHasNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - Either, TitanOperationStatus> resourcesByTypeEither = titanDao.getByCriteria(null, props, propsHasNotToMatch, JsonParseFlagEnum.ParseMetadata); - - if (resourcesByTypeEither.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(resourcesByTypeEither.right().value())); - } - - List vertexList = resourcesByTypeEither.left().value(); - List components = new ArrayList<>(); - - for (GraphVertex vertex : vertexList) { - components.add(getToscaElementByOperation(vertex, filterBy).left().value()); - } - - return Either.left(components); - } - - public void commit() { - titanDao.commit(); - } - - public Either updateDistributionStatus(Service service, User user, DistributionStatusEnum distributionStatus) { - Either updateDistributionStatus = topologyTemplateOperation.updateDistributionStatus(service.getUniqueId(), user, distributionStatus); - if (updateDistributionStatus.isRight()) { - return Either.right(updateDistributionStatus.right().value()); - } - GraphVertex serviceV = updateDistributionStatus.left().value(); - service.setDistributionStatus(distributionStatus); - service.setLastUpdateDate((Long) serviceV.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE)); - return Either.left(service); - } - - public Either updateComponentLastUpdateDateOnGraph(Component component) { - - Either result = null; - GraphVertex serviceVertex; - Either updateRes = null; - Either getRes = titanDao.getVertexById(component.getUniqueId(), JsonParseFlagEnum.ParseMetadata); - if (getRes.isRight()) { - TitanOperationStatus status = getRes.right().value(); - log.error("Failed to fetch component {}. status is {}", component.getUniqueId(), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); - } - if (result == null) { - serviceVertex = getRes.left().value(); - long lastUpdateDate = System.currentTimeMillis(); - serviceVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, lastUpdateDate); - component.setLastUpdateDate(lastUpdateDate); - updateRes = titanDao.updateVertex(serviceVertex); - if (updateRes.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateRes.right().value())); - } - } - if (result == null) { - result = Either.left(ModelConverter.convertToComponentMetadata(updateRes.left().value())); - } - return result; - } - - public HealingTitanDao getTitanDao() { - return titanDao; - } - - public Either, StorageOperationStatus> getCertifiedServicesWithDistStatus(Set distStatus) { - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - - return getServicesWithDistStatus(distStatus, propertiesToMatch); - } - - public Either, StorageOperationStatus> getServicesWithDistStatus(Set distStatus, Map additionalPropertiesToMatch) { - - List servicesAll = new ArrayList<>(); - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - - if (additionalPropertiesToMatch != null && !additionalPropertiesToMatch.isEmpty()) { - propertiesToMatch.putAll(additionalPropertiesToMatch); - } - - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - if (distStatus != null && !distStatus.isEmpty()) { - for (DistributionStatusEnum state : distStatus) { - propertiesToMatch.put(GraphPropertyEnum.DISTRIBUTION_STATUS, state.name()); - Either, StorageOperationStatus> fetchServicesByCriteria = fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); - if (fetchServicesByCriteria.isRight()) { - return fetchServicesByCriteria; - } else { - servicesAll = fetchServicesByCriteria.left().value(); - } - } - return Either.left(servicesAll); - } else { - return fetchServicesByCriteria(servicesAll, propertiesToMatch, propertiesNotToMatch); - } - } - - private Either, StorageOperationStatus> fetchServicesByCriteria(List servicesAll, Map propertiesToMatch, Map propertiesNotToMatch) { - Either, TitanOperationStatus> getRes = titanDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll); - if (getRes.isRight()) { - if (getRes.right().value() != TitanOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified services by match properties {} not match properties {} . Status is {}. ", propertiesToMatch, propertiesNotToMatch, getRes.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getRes.right().value())); - } - } else { - for (GraphVertex vertex : getRes.left().value()) { - Either getServiceRes = topologyTemplateOperation.getLightComponent(vertex, ComponentTypeEnum.SERVICE, new ComponentParametersView(true)); - - if (getServiceRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch certified service {}. Status is {}. ", vertex.getJsonMetadataField(JsonPresentationFields.NAME), getServiceRes.right().value()); - return Either.right(getServiceRes.right().value()); - } else { - servicesAll.add(ModelConverter.convertFromToscaElement(getServiceRes.left().value())); - } - } - } - return Either.left(servicesAll); - } - - public void rollback() { - titanDao.rollback(); - } - - public StorageOperationStatus addDeploymentArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map finalDeploymentArtifacts) { - Map instDeplArtifacts = finalDeploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - - return nodeTemplateOperation.addDeploymentArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); - } - - public StorageOperationStatus addInformationalArtifactsToInstance(String componentId, ComponentInstance componentInstance, Map artifacts) { - StorageOperationStatus status = StorageOperationStatus.OK; - if (MapUtils.isNotEmpty(artifacts)) { - Map instDeplArtifacts = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - status = nodeTemplateOperation.addInformationalArtifactsToInstance(componentId, componentInstance.getUniqueId(), instDeplArtifacts); - } - return status; - } - - public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) { - return nodeTemplateOperation.generateCustomizationUUIDOnInstance(componentId, instanceId); - } - - public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List groupInstances) { - return nodeTemplateOperation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances); - } - - public Either addPropertyToComponent(String propertyName, - PropertyDefinition newPropertyDefinition, - Component component) { - - Either result = null; - Either getUpdatedComponentRes = null; - newPropertyDefinition.setName(propertyName); - - StorageOperationStatus status = getToscaElementOperation(component) - .addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the component {}. Status is {}. ", propertyName, component.getName(), status); - result = Either.right(status); - } - if (result == null) { - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreProperties(false); - filter.setIgnoreInputs(false); - getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); - if (getUpdatedComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated component {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); - result = Either.right(status); - } - } - if (result == null) { - PropertyDefinition newProperty = null; - List properties = - (getUpdatedComponentRes.left().value()).getProperties(); - if (CollectionUtils.isNotEmpty(properties)) { - Optional propertyOptional = properties.stream().filter( - propertyEntry -> propertyEntry.getName().equals(propertyName)).findAny(); - if (propertyOptional.isPresent()) { - newProperty = propertyOptional.get(); - } - } - if (newProperty == null) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the component {}. Status is {}. ", propertyName, component.getUniqueId(), StorageOperationStatus.NOT_FOUND); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } else { - result = Either.left(newProperty); - } - } - return result; - } - public StorageOperationStatus deletePropertyOfComponent(Component component, String propertyName) { - return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, propertyName, JsonPresentationFields.NAME); - } - - public StorageOperationStatus deleteAttributeOfResource(Component component, String attributeName) { - return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, attributeName, JsonPresentationFields.NAME); - } - - public StorageOperationStatus deleteInputOfResource(Component resource, String inputName) { - return getToscaElementOperation(resource).deleteToscaDataElement(resource.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputName, JsonPresentationFields.NAME); - } - - /** - * Deletes a data type from a component. - * @param component the container which has the data type - * @param dataTypeName the data type name to be deleted - * @return Operation result. - */ - public StorageOperationStatus deleteDataTypeOfComponent(Component component, String dataTypeName) { - return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.DATA_TYPES, VertexTypeEnum.DATA_TYPES, dataTypeName, JsonPresentationFields.NAME); - } - - public Either updatePropertyOfComponent(Component component, - PropertyDefinition newPropertyDefinition) { - - Either getUpdatedComponentRes = null; - Either result = null; - StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, newPropertyDefinition, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the property {} to the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getName(), status); - result = Either.right(status); - } - if (result == null) { - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreProperties(false); - getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); - if (getUpdatedComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated resource {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value()); - result = Either.right(status); - } - } - if (result == null) { - Optional newProperty = (getUpdatedComponentRes.left().value()) - .getProperties().stream().filter(p -> p.getName().equals(newPropertyDefinition.getName())).findAny(); - if (newProperty.isPresent()) { - result = Either.left(newProperty.get()); - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added property {} on the resource {}. Status is {}. ", newPropertyDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - return result; - } - - - - public Either addAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { - - Either getUpdatedComponentRes = null; - Either result = null; - if (newAttributeDef.getUniqueId() == null || newAttributeDef.getUniqueId().isEmpty()) { - String attUniqueId = UniqueIdBuilder.buildAttributeUid(component.getUniqueId(), newAttributeDef.getName()); - newAttributeDef.setUniqueId(attUniqueId); - } - - StorageOperationStatus status = getToscaElementOperation(component).addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); - result = Either.right(status); - } - if (result == null) { - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreAttributesFrom(false); - getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); - if (getUpdatedComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); - result = Either.right(status); - } - } - if (result == null) { - Optional newAttribute = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); - if (newAttribute.isPresent()) { - result = Either.left(newAttribute.get()); - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - return result; - } - - public Either updateAttributeOfResource(Component component, PropertyDefinition newAttributeDef) { - - Either getUpdatedComponentRes = null; - Either result = null; - StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.ATTRIBUTES, VertexTypeEnum.ATTRIBUTES, newAttributeDef, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_ADD_THE_PROPERTY_TO_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getName(), status); - result = Either.right(status); - } - if (result == null) { - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreAttributesFrom(false); - getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); - if (getUpdatedComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); - result = Either.right(status); - } - } - if (result == null) { - Optional newProperty = ((Resource) getUpdatedComponentRes.left().value()).getAttributes().stream().filter(p -> p.getName().equals(newAttributeDef.getName())).findAny(); - if (newProperty.isPresent()) { - result = Either.left(newProperty.get()); - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FIND_RECENTLY_ADDED_PROPERTY_ON_THE_RESOURCE_STATUS_IS, newAttributeDef.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - return result; - } - - public Either updateInputOfComponent(Component component, InputDefinition newInputDefinition) { - - Either getUpdatedComponentRes = null; - Either result = null; - StorageOperationStatus status = getToscaElementOperation(component).updateToscaDataOfToscaElement(component.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, newInputDefinition, JsonPresentationFields.NAME); - if (status != StorageOperationStatus.OK) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update the input {} to the component {}. Status is {}. ", newInputDefinition.getName(), component.getName(), status); - result = Either.right(status); - } - if (result == null) { - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreInputs(false); - getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter); - if (getUpdatedComponentRes.isRight()) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_UPDATED_RESOURCE_STATUS_IS, component.getUniqueId(), getUpdatedComponentRes.right().value()); - result = Either.right(status); - } - } - if (result == null) { - Optional updatedInput = getUpdatedComponentRes.left().value().getInputs().stream().filter(p -> p.getName().equals(newInputDefinition.getName())).findAny(); - if (updatedInput.isPresent()) { - result = Either.left(updatedInput.get()); - } else { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently updated inputs {} on the resource {}. Status is {}. ", newInputDefinition.getName(), component.getUniqueId(), StorageOperationStatus.NOT_FOUND); - result = Either.right(StorageOperationStatus.NOT_FOUND); - } - } - return result; - } - - /** - * method - ename the group instances after referenced container name renamed flow - VF rename -(triggers)-> Group rename - * - * @param containerComponent - container such as service - * @param componentInstance - context component - * @param componentInstanceId - id - * @return - successfull/failed status - **/ - public Either cleanAndAddGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, String componentInstanceId) { - String uniqueId = componentInstance.getUniqueId(); - StorageOperationStatus status = nodeTemplateOperation.deleteToscaDataDeepElementsBlockOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, uniqueId); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete group instances for container {}. error {] ", componentInstanceId, status); - return Either.right(status); - } - if (componentInstance.getGroupInstances() != null) { - status = addGroupInstancesToComponentInstance(containerComponent, componentInstance, componentInstance.getGroupInstances()); - if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) { - CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add group instances for container {}. error {] ", componentInstanceId, status); - return Either.right(status); - } - } - return Either.left(status); - } - - public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groups, Map> groupInstancesArtifacts) { - return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups, groupInstancesArtifacts); - } - - public Either, StorageOperationStatus> updateGroupsOnComponent(Component component, List updatedGroups) { - return groupsOperation.updateGroups(component, updatedGroups, true); - } - - public Either, StorageOperationStatus> updateGroupInstancesOnComponent(Component component, String instanceId, List updatedGroupInstances) { - return groupsOperation.updateGroupInstances(component, instanceId, updatedGroupInstances); - } - - public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List groupInstances) { - return nodeTemplateOperation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groupInstances); - } - - public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map deploymentArtifacts) { - return nodeTemplateOperation.addDeploymentArtifactsToComponentInstance(containerComponent, componentInstance, deploymentArtifacts); - } - - public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { - return nodeTemplateOperation.updateComponentInstanceProperty(containerComponent, componentInstanceId, property); - } - - public StorageOperationStatus updateComponentInstanceProperties(Component containerComponent, String componentInstanceId, List properties) { - return nodeTemplateOperation.updateComponentInstanceProperties(containerComponent, componentInstanceId, properties); - } - - - public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) { - return nodeTemplateOperation.addComponentInstanceProperty(containerComponent, componentInstanceId, property); - } - - public StorageOperationStatus updateComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ - return nodeTemplateOperation.updateComponentInstanceAttribute(containerComponent, componentInstanceId, property); - } - - public StorageOperationStatus addComponentInstanceAttribute(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property){ - return nodeTemplateOperation.addComponentInstanceAttribute(containerComponent, componentInstanceId, property); - } - - public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { - return nodeTemplateOperation.updateComponentInstanceInput(containerComponent, componentInstanceId, property); - } - - public StorageOperationStatus updateComponentInstanceInputs(Component containerComponent, String componentInstanceId, List instanceInputs) { - return nodeTemplateOperation.updateComponentInstanceInputs(containerComponent, componentInstanceId, instanceInputs); - } - - public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) { - return nodeTemplateOperation.addComponentInstanceInput(containerComponent, componentInstanceId, property); - } - - public void setNodeTypeOperation(NodeTypeOperation nodeTypeOperation) { - this.nodeTypeOperation = nodeTypeOperation; - } - - public void setTopologyTemplateOperation(TopologyTemplateOperation topologyTemplateOperation) { - this.topologyTemplateOperation = topologyTemplateOperation; - } - - public StorageOperationStatus deleteComponentInstanceInputsFromTopologyTemplate(Component containerComponent, List inputsToDelete) { - return topologyTemplateOperation.deleteToscaDataElements(containerComponent.getUniqueId(), EdgeLabelEnum.INPUTS, inputsToDelete.stream().map(PropertyDataDefinition::getName).collect(Collectors.toList())); - } - - public StorageOperationStatus updateComponentInstanceCapabiltyProperty(Component containerComponent, String componentInstanceUniqueId, String capabilityUniqueId, ComponentInstanceProperty property) { - return nodeTemplateOperation.updateComponentInstanceCapabilityProperty(containerComponent, componentInstanceUniqueId, capabilityUniqueId, property); - } - - public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceUniqueId) { - return convertComponentInstanceProperties(containerComponent, componentInstanceUniqueId) - .map(instanceCapProps -> topologyTemplateOperation.updateComponentInstanceCapabilityProperties(containerComponent, componentInstanceUniqueId, instanceCapProps)) - .orElse(StorageOperationStatus.NOT_FOUND); - } - - public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceUniqueId) { - MapInterfaceDataDefinition mapInterfaceDataDefinition = - convertComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId); - return topologyTemplateOperation - .updateComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId, mapInterfaceDataDefinition); - } - - public StorageOperationStatus updateComponentCalculatedCapabilitiesProperties(Component containerComponent) { - Map mapCapabiltyPropertyMap = - convertComponentCapabilitiesProperties(containerComponent); - return nodeTemplateOperation.overrideComponentCapabilitiesProperties(containerComponent, mapCapabiltyPropertyMap); - } - - public StorageOperationStatus deleteAllCalculatedCapabilitiesRequirements(String topologyTemplateId) { - StorageOperationStatus status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES); - if (status == StorageOperationStatus.OK) { - status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS); - } - if (status == StorageOperationStatus.OK) { - status = topologyTemplateOperation.removeToscaData(topologyTemplateId, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES); - } - return status; - } - - public Either shouldUpgradeToLatestDerived(Resource clonedResource) { - String componentId = clonedResource.getUniqueId(); - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.debug(COULDNT_FETCH_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - - } - GraphVertex nodeTypeV = getVertexEither.left().value(); - - ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(clonedResource); - - Either shouldUpdateDerivedVersion = nodeTypeOperation.shouldUpdateDerivedVersion(toscaElementToUpdate, nodeTypeV); - if (shouldUpdateDerivedVersion.isRight() && StorageOperationStatus.OK != shouldUpdateDerivedVersion.right().value()) { - log.debug("Failed to update derived version for node type {} derived {}, error: {}", componentId, clonedResource.getDerivedFrom().get(0), shouldUpdateDerivedVersion.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } - if (shouldUpdateDerivedVersion.isLeft()) { - return Either.left(ModelConverter.convertFromToscaElement(shouldUpdateDerivedVersion.left().value())); - } - return Either.left(clonedResource); - } - - /** - * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId - */ - public Either, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityName, String capabilityType, String ownerId) { - return topologyTemplateOperation.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId); - } - - private MapInterfaceDataDefinition convertComponentInstanceInterfaces(Component currComponent, - String componentInstanceId) { - MapInterfaceDataDefinition mapInterfaceDataDefinition = new MapInterfaceDataDefinition(); - List componentInterface = currComponent.getComponentInstancesInterfaces().get(componentInstanceId); - - if(CollectionUtils.isNotEmpty(componentInterface)) { - componentInterface.stream().forEach(interfaceDef -> mapInterfaceDataDefinition.put - (interfaceDef.getUniqueId(), interfaceDef)); - } - - return mapInterfaceDataDefinition; - } - - private Map convertComponentCapabilitiesProperties(Component currComponent) { - Map map = ModelConverter.extractCapabilityPropertiesFromGroups(currComponent.getGroups(), true); - map.putAll(ModelConverter.extractCapabilityProperteisFromInstances(currComponent.getComponentInstances(), true)); - return map; - } - - private Optional convertComponentInstanceProperties(Component component, String instanceId) { - return component.fetchInstanceById(instanceId) - .map(ci -> ModelConverter.convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), instanceId)); - } - - public Either associatePolicyToComponent(String componentId, PolicyDefinition policyDefinition, int counter) { - Either result = null; - Either getVertexEither; - getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata); - if (getVertexEither.isRight()) { - log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } else { - if (getVertexEither.left().value().getLabel() != VertexTypeEnum.TOPOLOGY_TEMPLATE) { - log.error("Policy association to component of Tosca type {} is not allowed. ", getVertexEither.left().value().getLabel()); - result = Either.right(StorageOperationStatus.BAD_REQUEST); - } - } - if (result == null) { - StorageOperationStatus status = topologyTemplateOperation.addPolicyToToscaElement(getVertexEither.left().value(), policyDefinition, counter); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - if (result == null) { - result = Either.left(policyDefinition); - } - return result; - } - - public StorageOperationStatus associatePoliciesToComponent(String componentId, List policies) { - log.debug("#associatePoliciesToComponent - associating policies for component {}.", componentId); - return titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata) - .either(containerVertex -> topologyTemplateOperation.addPoliciesToToscaElement(containerVertex, policies), - DaoStatusConverter::convertTitanStatusToStorageStatus); - } - - public Either updatePolicyOfComponent(String componentId, PolicyDefinition policyDefinition) { - Either result = null; - Either getVertexEither; - getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value())); - } - if (result == null) { - StorageOperationStatus status = topologyTemplateOperation.updatePolicyOfToscaElement(getVertexEither.left().value(), policyDefinition); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - } - if (result == null) { - result = Either.left(policyDefinition); - } - return result; - } - - public StorageOperationStatus updatePoliciesOfComponent(String componentId, List policyDefinition) { - log.debug("#updatePoliciesOfComponent - updating policies for component {}", componentId); - return titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse) - .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) - .either(containerVertex -> topologyTemplateOperation.updatePoliciesOfToscaElement(containerVertex, policyDefinition), - err -> err); - } - - public StorageOperationStatus removePolicyFromComponent(String componentId, String policyId) { - StorageOperationStatus status = null; - Either getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse); - if (getVertexEither.isRight()) { - log.error(COULDNT_FETCH_A_COMPONENT_WITH_AND_UNIQUE_ID_ERROR, componentId, getVertexEither.right().value()); - status = DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()); - } - if (status == null) { - status = topologyTemplateOperation.removePolicyFromToscaElement(getVertexEither.left().value(), policyId); - } - return status; - } - - public boolean canAddGroups(String componentId) { - GraphVertex vertex = titanDao.getVertexById(componentId) - .left() - .on(this::onTitanError); - return topologyTemplateOperation.hasEdgeOfType(vertex, EdgeLabelEnum.GROUPS); - } - - GraphVertex onTitanError(TitanOperationStatus toe) { - throw new StorageException( - DaoStatusConverter.convertTitanStatusToStorageStatus(toe)); - } - - public void updateNamesOfCalculatedCapabilitiesRequirements(String componentId){ - topologyTemplateOperation - .updateNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); - } - - public void revertNamesOfCalculatedCapabilitiesRequirements(String componentId) { - topologyTemplateOperation - .revertNamesOfCalculatedCapabilitiesRequirements(componentId, getTopologyTemplate(componentId)); - } - - private TopologyTemplate getTopologyTemplate(String componentId) { - return (TopologyTemplate)topologyTemplateOperation - .getToscaElement(componentId, getFilterComponentWithCapProperties()) - .left() - .on(this::throwStorageException); - } - - private ComponentParametersView getFilterComponentWithCapProperties() { - ComponentParametersView filter = new ComponentParametersView(); - filter.setIgnoreCapabiltyProperties(false); - return filter; - } - - private ToscaElement throwStorageException(StorageOperationStatus status) { - throw new StorageException(status); - } - - public Either isComponentInUse(String componentId) { - final List forbiddenEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); - Either vertexById = titanDao.getVertexById(componentId); - if (vertexById.isLeft()) { - for (EdgeLabelEnum edgeLabelEnum : forbiddenEdgeLabelEnums) { - Iterator edgeItr = vertexById.left().value().getVertex().edges(Direction.IN, edgeLabelEnum.name()); - if(edgeItr != null && edgeItr.hasNext()){ - return Either.left(true); - } - } - } - return Either.left(false); - } - - public Either, StorageOperationStatus> getComponentListByInvariantUuid - (String componentInvariantUuid, Map additionalPropertiesToMatch) { - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - if (MapUtils.isNotEmpty(additionalPropertiesToMatch)) { - propertiesToMatch.putAll(additionalPropertiesToMatch); - } - propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, componentInvariantUuid); - - Either, TitanOperationStatus> vertexEither = titanDao.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata); - - if (vertexEither.isRight()) { - log.debug("Couldn't fetch metadata for component with type {} and invariantUUId {}, error: {}", componentInvariantUuid, vertexEither.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexEither.right().value())); - } - List vertexList = vertexEither.isLeft() ? vertexEither.left().value() : null; - - if (vertexList == null || vertexList.isEmpty()) { - log.debug("Component with invariantUUId {} was not found", componentInvariantUuid); - return Either.right(StorageOperationStatus.NOT_FOUND); - } - - ArrayList components = new ArrayList<>(); - for (GraphVertex vertex : vertexList) { - Either toscaElementByOperation = getToscaElementByOperation(vertex); - if (toscaElementByOperation.isRight()) { - log.debug("Could not fetch the following Component by Invariant UUID {}", vertex.getUniqueId()); - return Either.right(toscaElementByOperation.right().value()); - } - components.add(toscaElementByOperation.left().value()); - } - - return Either.left(components); - } - - public Either, StorageOperationStatus> getParentComponents(String componentId) { - List parentComponents = new ArrayList<>(); - final List relationEdgeLabelEnums = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF); - Either vertexById = titanDao.getVertexById(componentId); - if (vertexById.isLeft()) { - for (EdgeLabelEnum edgeLabelEnum : relationEdgeLabelEnums) { - Either parentVertexEither = titanDao.getParentVertex(vertexById.left().value(), edgeLabelEnum, JsonParseFlagEnum.ParseJson); - if(parentVertexEither.isLeft()){ - Either componentEither = getToscaElement(parentVertexEither.left().value().getUniqueId()); - if(componentEither.isLeft()){ - parentComponents.add(componentEither.left().value()); - } - } - } - } - return Either.left(parentComponents); - } - public void updateCapReqPropertiesOwnerId(String componentId) { - topologyTemplateOperation - .updateCapReqPropertiesOwnerId(componentId, getTopologyTemplate(componentId)); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperation.java deleted file mode 100644 index 5faa6bb8ad..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperation.java +++ /dev/null @@ -1,225 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.ComponentDependency; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.springframework.stereotype.Component; - -import java.util.*; -import java.util.function.Function; -import java.util.stream.Collectors; - -@Component -public class UpgradeOperation extends BaseOperation { - private static final Logger log = Logger.getLogger(UpgradeOperation.class.getName()); - - public Either, StorageOperationStatus> getComponentDependencies(String componentId) { - Either vertexById = titanDao.getVertexById(componentId); - if (vertexById.isRight()) { - log.debug("Failed to fetch vertex with id {} error {}", componentId, vertexById.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexById.right().value())); - } - List dependencies = new ArrayList<>(); - - GraphVertex vertex = vertexById.left().value(); - - StorageOperationStatus status = fillDependenciesByVertex(componentId, dependencies, vertex); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - - GraphVertex vertexToStart = vertex; - Function> getNextElement = vertexP -> titanDao.getParentVertex(vertexP, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); - status = handleVersionChain(componentId, dependencies, vertex, getNextElement); - if (status != StorageOperationStatus.OK) { - return Either.right(status); - } - vertex = vertexToStart; - getNextElement = vertexP -> titanDao.getChildVertex(vertexP, EdgeLabelEnum.VERSION, JsonParseFlagEnum.ParseAll); - status = handleVersionChain(componentId, dependencies, vertex, getNextElement); - - return status == StorageOperationStatus.OK ? Either.left(dependencies) : Either.right(status); - } - - private StorageOperationStatus handleVersionChain(String componentId, List dependencies, GraphVertex vertexToStart, Function> getNextElement) { - - StorageOperationStatus status; - boolean nextInChain = true; - GraphVertex vertex = vertexToStart; - Either nextInChainV; - while (nextInChain) { - nextInChainV = getNextElement.apply(vertex); - if (nextInChainV.isRight()) { - nextInChain = false; - } else { - vertex = nextInChainV.left().value(); - status = fillDependenciesByVertex(componentId, dependencies, vertex); - if (status != StorageOperationStatus.OK) { - return status; - } - } - } - return StorageOperationStatus.OK; - } - - private StorageOperationStatus fillDependenciesByVertex(String componentId, List dependencies, GraphVertex vertex) { - StorageOperationStatus status = StorageOperationStatus.OK; - if ( needToAddToDepenedency(vertex) ) { - ComponentDependency dependency = fillDataFromVertex(vertex, null, null); - - List dependList = Arrays.asList(EdgeLabelEnum.INSTANCE_OF, EdgeLabelEnum.PROXY_OF, EdgeLabelEnum.ALLOTTED_OF); - for (EdgeLabelEnum label : dependList) { - status = fillDependenciesByLabel(componentId, vertex, dependency, label); - if (status != StorageOperationStatus.OK) { - log.debug("Failed to create dependencies for component {} and label {} status {}", componentId, label, status); - break; - } - } - if (status == StorageOperationStatus.OK) { - dependencies.add(dependency); - } - } - return status; - } - private boolean needToAddToDepenedency(GraphVertex vertex){ - Boolean isDeleted = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_DELETED); - Boolean isArchived = (Boolean) vertex.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); - return ( isDeleted == Boolean.TRUE || isArchived == Boolean.TRUE) ? false : true; - } - - private StorageOperationStatus fillDependenciesByLabel(String componentId, GraphVertex vertex, ComponentDependency dependency, EdgeLabelEnum label) { - Either, TitanOperationStatus> parentVertecies = titanDao.getParentVertecies(vertex, label, JsonParseFlagEnum.ParseAll); - if (parentVertecies.isRight() && parentVertecies.right().value() != TitanOperationStatus.NOT_FOUND) { - log.debug("Failed to fetch parent verticies by label INSTANCE_OF for vertex with id {} error {}", componentId, parentVertecies.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(parentVertecies.right().value()); - } - if (parentVertecies.isLeft()) { - List existIn = new ArrayList<>( ); - parentVertecies.left().value().forEach(v -> handleHighestVersion(vertex, label, existIn, v) ); - dependency.addDependencies(existIn); - } - return StorageOperationStatus.OK; - } - - private void handleHighestVersion(GraphVertex vertexOrigin, EdgeLabelEnum label, List exisIn, GraphVertex containerVertex) { - Boolean isHighest = (Boolean) containerVertex.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - if ( isHighest && needToAddToDepenedency(containerVertex) ) { - TitanVertex titanVertex = containerVertex.getVertex(); - Iterator edges = titanVertex.edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); - //verify that it is a last version - highest by version number - if ( edges == null || !edges.hasNext() ){ - ComponentDependency container = fillDataFromVertex(containerVertex, vertexOrigin.getUniqueId(), label); - boolean addToDependency = true; - if (label == EdgeLabelEnum.ALLOTTED_OF) { - //in case of not full allotted chain not add to dependency list - addToDependency = findAllottedChain(containerVertex, container); - } - if ( addToDependency ){ - exisIn.add(container); - } - } - } - } - - private boolean findAllottedChain(GraphVertex vertex, ComponentDependency container) { - Either, TitanOperationStatus> parentVertecies = titanDao.getParentVertecies(vertex, EdgeLabelEnum.INSTANCE_OF, JsonParseFlagEnum.ParseAll); - if (parentVertecies.isLeft()) { - List existIn = new ArrayList<>(); - parentVertecies.left().value().forEach(v -> { - Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - if ( isHighest && needToAddToDepenedency(v) ) { - TitanVertex titanVertex = v.getVertex(); - Iterator edges = titanVertex.edges(Direction.OUT, EdgeLabelEnum.VERSION.name()); - //verify that it is a last version - highest by version number - if ( edges == null || !edges.hasNext() ){ - ComponentDependency parentContainer = fillDataFromVertex(v, vertex.getUniqueId(), EdgeLabelEnum.INSTANCE_OF); - existIn.add(parentContainer); - } - } - }); - if ( !existIn.isEmpty() ){ - container.setDependencies(existIn); - return true; - } - } - return false; - } - - private ComponentDependency fillDataFromVertex(GraphVertex v, String originId, EdgeLabelEnum edgeLabel) { - ComponentDependency container = new ComponentDependency(); - container.setName((String) v.getMetadataProperty(GraphPropertyEnum.NAME)); - container.setVersion((String) v.getMetadataProperty(GraphPropertyEnum.VERSION)); - container.setUniqueId(v.getUniqueId()); - container.setType((String) v.getMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE)); - container.setIcon((String) v.getJsonMetadataField(JsonPresentationFields.ICON)); - container.setState((String) v.getMetadataProperty(GraphPropertyEnum.STATE)); - - if (edgeLabel == EdgeLabelEnum.PROXY_OF || edgeLabel == EdgeLabelEnum.ALLOTTED_OF) { - findInstanceNames(v, originId, edgeLabel, container); - } - return container; - } - - private void findInstanceNames(GraphVertex v, String originId, EdgeLabelEnum edgeLabel, ComponentDependency container) { - Map jsonComposition = (Map) v.getJson(); - CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - TitanVertex vertex = v.getVertex(); - Iterator edges = vertex.edges(Direction.OUT, edgeLabel.name()); - while (edges != null && edges.hasNext()) { - Edge edge = edges.next(); - TitanVertex inVertex = (TitanVertex) edge.inVertex(); - String id = (String) titanDao.getProperty(inVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()); - if (id.equals(originId)) { - List instanceOnEdge = (List) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES); - Map componentInstances = compositionDataDefinition.getComponentInstances(); - - if (componentInstances != null) { - List ciNames = componentInstances - .values() - .stream() - .filter(ci -> instanceOnEdge.contains(ci.getUniqueId())) - .map(ComponentInstanceDataDefinition::getName) - .collect(Collectors.toList()); - if (ciNames != null && !ciNames.isEmpty()) { - container.setInstanceNames(ciNames); - break; - } - } - } - } - } - - public List getInstanceIdFromAllottedEdge(String resourceId, String serviceInvariantUUID) { - Either vertexById = titanDao.getVertexById(resourceId); - if ( vertexById.isLeft() ){ - GraphVertex vertexG = vertexById.left().value(); - TitanVertex vertex = vertexG.getVertex(); - Iterator edges = vertex.edges(Direction.OUT, EdgeLabelEnum.ALLOTTED_OF.name()); - while ( edges != null && edges.hasNext() ){ - Edge edge = edges.next(); - TitanVertex inVertex = (TitanVertex)edge.inVertex(); - String vertexInInvUUID = (String) titanDao.getProperty(inVertex, GraphPropertyEnum.INVARIANT_UUID.getProperty()); - if ( vertexInInvUUID.equals(serviceInvariantUUID) ){ - return (List) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES) ; - } - } - } - return new ArrayList<>(); - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityRequirementNameResolver.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityRequirementNameResolver.java deleted file mode 100644 index 6bdce99d95..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityRequirementNameResolver.java +++ /dev/null @@ -1,394 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.utils; - -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang3.StringUtils; -import org.openecomp.sdc.be.config.BeEcompErrorManager; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.utils.ComponentUtilities; -import org.openecomp.sdc.common.log.wrappers.Logger; -import java.util.*; -import java.util.function.Function; -import java.util.stream.Collectors; -import static org.apache.commons.collections.CollectionUtils.isNotEmpty; -import static org.apache.commons.lang3.StringUtils.isBlank; - -public class CapabilityRequirementNameResolver { - - private static final Logger log = Logger.getLogger(CapabilityRequirementNameResolver.class); - private static final String PATH_DELIMITER = "."; - - private CapabilityRequirementNameResolver() { - } - - public static void updateNamesOfCalculatedCapabilitiesRequirements(TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { - Map componentCacheToRepair = new HashMap<>(); - log.debug("#updateNamesOfCalculatedCapabilitiesRequirements"); - updateCalculatedCapabilitiesNames(componentCacheToRepair, toscaElement, ownerId, ownerName, originGetter); - updateCalculatedRequirementsNames(componentCacheToRepair, toscaElement, ownerId, ownerName, originGetter); - updateCalculatedCapabilitiesPropertiesKeys(toscaElement, ownerId); - } - - private static void updateCalculatedCapabilitiesPropertiesKeys(TopologyTemplate toscaElement, String ownerId) { - if (calCapPropertiesExist(toscaElement, ownerId)) { - MapCapabilityProperty newProps = new MapCapabilityProperty(); - toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) - .getMapToscaDataDefinition() - .forEach((k, v) -> updateAndAddCalculatedCapabilitiesProperties(k, v, toscaElement.getCalculatedCapabilities().get(ownerId), newProps)); - if (MapUtils.isNotEmpty(newProps.getMapToscaDataDefinition())) { - toscaElement.getCalculatedCapabilitiesProperties().put(ownerId, newProps); - } - } - } - - private static boolean calCapPropertiesExist(TopologyTemplate toscaElement, String ownerId) { - return toscaElement.getCalculatedCapabilitiesProperties() != null - && toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) != null - && MapUtils.isNotEmpty(toscaElement.getCalculatedCapabilitiesProperties().get(ownerId).getMapToscaDataDefinition()) - && capabilitiesExist(toscaElement, ownerId); - } - - private static void updateCalculatedRequirementsNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { - if (requirementsExist(toscaElement, ownerId)) { - String prefix = ownerName + PATH_DELIMITER; - repairReqNames(componentCacheToRepair, toscaElement, ownerId, originGetter); - toscaElement.getCalculatedRequirements().get(ownerId) - .getMapToscaDataDefinition().values().stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(r -> { - if (isRequiredToRepair(r.getName())) { - BeEcompErrorManager.getInstance() - .logBeComponentMissingError("The empty name of the requirement was found. Id: " + r.getUniqueId() + ", ownerId: " + ownerId + ", ownerName: " + ownerName, - toscaElement.getComponentType().getValue(), toscaElement.getName()); - } - if (ComponentUtilities.isNotUpdatedCapReqName(prefix, r.getName(), r.getPreviousName())) { - if (StringUtils.isNotEmpty(r.getPreviousName())) { - r.setParentName(r.getPreviousName()); - } - r.setPreviousName(r.getName()); - } - r.setName(prefix + r.getPreviousName()); - }); - } - } - - private static boolean requirementsExist(TopologyTemplate toscaElement, String ownerId) { - return toscaElement.getCalculatedRequirements() != null - && toscaElement.getCalculatedRequirements().get(ownerId) != null - && MapUtils.isNotEmpty(toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition()); - } - - private static void updateCalculatedCapabilitiesNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, String ownerName, Function originGetter) { - if (capabilitiesExist(toscaElement, ownerId)) { - String prefix = ownerName + PATH_DELIMITER; - repairCapNames(componentCacheToRepair, toscaElement, ownerId, originGetter); - toscaElement.getCalculatedCapabilities().get(ownerId) - .getMapToscaDataDefinition().values().stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(c -> { - if (isRequiredToRepair(c.getName())) { - BeEcompErrorManager.getInstance() - .logBeComponentMissingError("The empty name of the capability was found. Id: " + c.getUniqueId() + ", ownerId: " + ownerId + ", ownerName: " + ownerName, - toscaElement.getComponentType().getValue(), toscaElement.getName()); - } - if (ComponentUtilities.isNotUpdatedCapReqName(prefix, c.getName(), c.getPreviousName())) { - if (StringUtils.isNotEmpty(c.getPreviousName())) { - c.setParentName(c.getPreviousName()); - } - c.setPreviousName(c.getName()); - } - c.setName(prefix + c.getPreviousName()); - }); - } - } - - private static boolean capabilitiesExist(TopologyTemplate toscaElement, String ownerId) { - return toscaElement.getCalculatedCapabilities() != null - && toscaElement.getCalculatedCapabilities().get(ownerId) != null - && MapUtils.isNotEmpty(toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition()); - } - - private static void repairCapNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { - log.debug("#repairCapNames"); - boolean emptyNameFound = toscaElement.getCalculatedCapabilities() != null - && toscaElement.getCalculatedCapabilities().get(ownerId) != null - && toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition() != null - && toscaElement.getCalculatedCapabilities().get(ownerId).getMapToscaDataDefinition().values() - .stream() - .filter(Objects::nonNull) - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .filter(Objects::nonNull) - .anyMatch(c -> isRequiredToRepair(c.getName())); - - ComponentInstanceDataDefinition instance = toscaElement.getComponentInstances() != null ? - toscaElement.getComponentInstances().get(ownerId) : null; - if (instance != null && emptyNameFound) { - log.debug("#repairCapNames - Going to repair the name of the capability for the owner {}. ", ownerId); - toscaElement.getCalculatedCapabilities().get(ownerId) - .getMapToscaDataDefinition().values() - .stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(c -> repairCapName(componentCacheToRepair, instance, c, originGetter)); - } - } - - private static void repairReqNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { - log.debug("#repairReqNames"); - boolean emptyNameFound = toscaElement.getCalculatedRequirements() != null - && toscaElement.getCalculatedRequirements().get(ownerId) != null - && toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition() != null - && toscaElement.getCalculatedRequirements().get(ownerId).getMapToscaDataDefinition().values() - .stream() - .filter(Objects::nonNull) - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .filter(Objects::nonNull) - .anyMatch(r -> isRequiredToRepair(r.getName())); - - ComponentInstanceDataDefinition instance = toscaElement.getComponentInstances() != null ? - toscaElement.getComponentInstances().get(ownerId) : null; - if (instance != null && emptyNameFound) { - log.debug("#repairReqNames - Going to repair the name of the requirement for the owner {}. ", ownerId); - toscaElement.getCalculatedRequirements().get(ownerId) - .getMapToscaDataDefinition().values() - .stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(r -> repairReqName(componentCacheToRepair, instance, r, originGetter)); - } - } - - private static void repairCapName(Map componentCacheToRepair, ComponentInstanceDataDefinition instance, CapabilityDataDefinition capability, Function originGetter) { - if (isRequiredToRepair(capability.getName())) { - log.debug("#repairTopologyTemplateCapName - Going to build the name for the capability: ", capability.getUniqueId()); - buildSetCapName(componentCacheToRepair, capability, instance, originGetter); - } - } - - private static boolean isRequiredToRepair(String name) { - boolean isRequiredToRepair = StringUtils.isEmpty(name) || name.endsWith(".null") || name.contains(".null."); - if (isRequiredToRepair) { - log.debug("#isRequiredToRepair - The name {} should be repaired. ", name); - } else { - log.debug("#isRequiredToRepair - The name {} should not be repaired. ", name); - } - return isRequiredToRepair; - } - - private static void repairReqName(Map componentCacheToRepair, ComponentInstanceDataDefinition instance, RequirementDataDefinition requirement, Function originGetter) { - if (isRequiredToRepair(requirement.getName())) { - log.debug("#repairTopologyTemplateCapName - Going to build the name for the requirement: ", requirement.getUniqueId()); - buildSetReqName(componentCacheToRepair, requirement, instance, originGetter); - } - } - - private static void updateAndAddCalculatedCapabilitiesProperties(String stringKey, MapPropertiesDataDefinition properties, MapListCapabilityDataDefinition calculatedCapabilities, MapCapabilityProperty newProps) { - String[] key = stringKey.split(ModelConverter.CAP_PROP_DELIM); - String capType = key[key.length - 2]; - String capName = key[key.length - 1]; - Optional foundCapOpt = calculatedCapabilities.getMapToscaDataDefinition().get(capType) - .getListToscaDataDefinition().stream() - .filter(c -> StringUtils.isNotEmpty(c.getPreviousName()) && c.getPreviousName().equals(capName)) - .findFirst(); - foundCapOpt.ifPresent(capabilityDataDefinition -> key[key.length - 1] = capabilityDataDefinition.getName()); - newProps.put(buildCaLCapPropKey(key), properties); - } - - public static void revertNamesOfCalculatedCapabilitiesRequirements(TopologyTemplate toscaElement, String ownerId, Function originGetter) { - Map componentCacheToRepair = new HashMap<>(); - log.debug("#revertNamesOfCalculatedCapabilitiesRequirements"); - revertCalculatedCapabilitiesPropertiesKeys(componentCacheToRepair, toscaElement, ownerId, originGetter); - revertCalculatedCapabilitiesNames(toscaElement, ownerId); - revertCalculatedRequirementsNames(componentCacheToRepair, toscaElement, ownerId, originGetter); - } - - private static void revertCalculatedCapabilitiesPropertiesKeys(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { - repairCapNames(componentCacheToRepair, toscaElement, ownerId, originGetter); - if (calCapPropertiesExist(toscaElement, ownerId)) { - MapCapabilityProperty newProps = new MapCapabilityProperty(); - toscaElement.getCalculatedCapabilitiesProperties().get(ownerId) - .getMapToscaDataDefinition() - .forEach((k, v) -> revertAndAddCalculatedCapabilitiesProperties(k, v, toscaElement.getCalculatedCapabilities().get(ownerId), newProps)); - if (MapUtils.isNotEmpty(newProps.getMapToscaDataDefinition())) { - toscaElement.getCalculatedCapabilitiesProperties().put(ownerId, newProps); - } - } - } - - private static void revertCalculatedRequirementsNames(Map componentCacheToRepair, TopologyTemplate toscaElement, String ownerId, Function originGetter) { - repairReqNames(componentCacheToRepair, toscaElement, ownerId, originGetter); - if (requirementsExist(toscaElement, ownerId)) { - toscaElement.getCalculatedRequirements().get(ownerId) - .getMapToscaDataDefinition().values().stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(CapabilityRequirementNameResolver::revertReqNames); - } - } - - private static void revertReqNames(RequirementDataDefinition requirement) { - if (StringUtils.isNotEmpty(requirement.getPreviousName())) { - requirement.setName(requirement.getPreviousName()); - requirement.setPreviousName(requirement.getParentName()); - } - } - - private static void revertCalculatedCapabilitiesNames(TopologyTemplate toscaElement, String ownerId) { - if (capabilitiesExist(toscaElement, ownerId)) { - toscaElement.getCalculatedCapabilities().get(ownerId) - .getMapToscaDataDefinition().values().stream() - .flatMap(l -> l.getListToscaDataDefinition().stream()) - .forEach(CapabilityRequirementNameResolver::revertCapNames); - } - } - - private static void revertCapNames(CapabilityDataDefinition capability) { - if (StringUtils.isNotEmpty(capability.getPreviousName())) { - capability.setName(capability.getPreviousName()); - capability.setPreviousName(capability.getParentName()); - } - } - - private static void revertAndAddCalculatedCapabilitiesProperties(String stringKey, MapPropertiesDataDefinition properties, MapListCapabilityDataDefinition calculatedCapabilities, MapCapabilityProperty newProps) { - String[] key = stringKey.split(ModelConverter.CAP_PROP_DELIM); - String capType = key[key.length - 2]; - String capName = key[key.length - 1]; - Optional foundCapOpt = calculatedCapabilities.getMapToscaDataDefinition().get(capType) - .getListToscaDataDefinition().stream() - .filter(c -> c.getName().equals(capName) && StringUtils.isNotEmpty(c.getPreviousName())) - .findFirst(); - foundCapOpt.ifPresent(capabilityDataDefinition -> key[key.length - 1] = capabilityDataDefinition.getPreviousName()); - newProps.put(buildCaLCapPropKey(key), properties); - } - - private static String buildCaLCapPropKey(String[] keyArray) { - StringBuilder key = new StringBuilder(); - for (int i = 0; i < keyArray.length; ++i) { - key.append(keyArray[i]); - if (i < keyArray.length - 1) { - key.append(ModelConverter.CAP_PROP_DELIM); - } - } - return key.toString(); - } - - private static void buildSetCapName(Map componentsCache, CapabilityDataDefinition capability, ComponentInstanceDataDefinition instance, Function originGetter) { - List reducedPath = capability.getOwnerId() != null ? getReducedPathByOwner(capability.getPath(), capability.getOwnerId()) : getReducedPath(capability.getPath()); - log.debug("reducedPath for ownerId {}, reducedPath {} ", capability.getOwnerId(), reducedPath); - reducedPath.remove(reducedPath.size() - 1); - ToscaElement originComponent = getOriginComponent(componentsCache, instance, originGetter); - String name = isRequiredToRepair(capability.getParentName()) ? - extractNameFromUniqueId(capability.getUniqueId()) : capability.getParentName(); - StringBuilder repairedName = buildSubstitutedName(componentsCache, originComponent, reducedPath, originGetter); - log.debug("#buildSetCapName - The name for the capability was built: {}", repairedName); - - capability.setName(repairedName.append(name).toString()); - if (isRequiredToRepair(capability.getPreviousName())) { - capability.setPreviousName(capability.getName().substring(capability.getName().indexOf(PATH_DELIMITER) + 1)); - } - if (isRequiredToRepair(capability.getParentName())) { - capability.setParentName(name); - } - } - - private static void buildSetReqName(Map componentsCache, RequirementDataDefinition requirement, ComponentInstanceDataDefinition instance, Function originGetter) { - List reducedPath = requirement.getOwnerId() != null ? getReducedPathByOwner(requirement.getPath(), requirement.getOwnerId()) : getReducedPath(requirement.getPath()); - log.debug("reducedPath for ownerId {}, reducedPath {} ", requirement.getOwnerId(), reducedPath); - reducedPath.remove(reducedPath.size() - 1); - ToscaElement originComponent = getOriginComponent(componentsCache, instance, originGetter); - String name = isRequiredToRepair(requirement.getParentName()) ? - extractNameFromUniqueId(requirement.getUniqueId()) : requirement.getParentName(); - - StringBuilder repairedName = buildSubstitutedName(componentsCache, originComponent, reducedPath, originGetter); - log.debug("#buildSetReqName - The name for the capability was built: ", repairedName); - requirement.setName(repairedName.append(name).toString()); - if (isRequiredToRepair(requirement.getPreviousName())) { - requirement.setPreviousName(requirement.getName().substring(requirement.getName().indexOf(PATH_DELIMITER) + 1)); - } - if (isRequiredToRepair(requirement.getParentName())) { - requirement.setParentName(name); - } - } - - private static String extractNameFromUniqueId(String uniqueId) { - String[] uid = uniqueId.split("\\."); - return uid[uid.length - 1]; - } - - private static StringBuilder buildSubstitutedName(Map componentsCache, ToscaElement originComponent, List path, Function originGetter) { - StringBuilder substitutedName = new StringBuilder(); - log.debug("#buildSubstitutedName"); - if (isNotEmpty(path) && isTopologyTemplateNotCvfc(originComponent)) { - log.debug("#buildSubstitutedName"); - List reducedPath = getReducedPath(path); - Collections.reverse(reducedPath); - appendNameRecursively(componentsCache, originComponent, reducedPath.iterator(), substitutedName, originGetter); - } - return substitutedName; - } - - private static boolean isTopologyTemplateNotCvfc(ToscaElement originComponent) { - return originComponent.getToscaType() == ToscaElementTypeEnum.TOPOLOGY_TEMPLATE && originComponent.getResourceType() != ResourceTypeEnum.CVFC; - } - - private static ToscaElement getOriginComponent(Map componentsCache, ComponentInstanceDataDefinition instance, Function originGetter) { - if (componentsCache.containsKey(getActualComponentUid(instance))) { - return componentsCache.get(getActualComponentUid(instance)); - } - ToscaElement origin = originGetter.apply(instance); - componentsCache.put(origin.getUniqueId(), origin); - return origin; - } - - public static String getActualComponentUid(ComponentInstanceDataDefinition instance) { - return instance.getIsProxy() ? instance.getSourceModelUid() : instance.getComponentUid(); - } - - private static List getReducedPath(List path) { - return path.stream().distinct().collect(Collectors.toList()); - } - - private static void appendNameRecursively(Map componentsCache, ToscaElement originComponent, Iterator instanceIdIter, StringBuilder substitutedName, Function originGetter) { - log.debug("#appendNameRecursively"); - if (isTopologyTemplateNotCvfc(originComponent) - && MapUtils.isNotEmpty(((TopologyTemplate) originComponent).getComponentInstances()) && instanceIdIter.hasNext()) { - - String ownerId = instanceIdIter.next(); - Optional instanceOpt = ((TopologyTemplate) originComponent).getComponentInstances().values().stream().filter(i -> i.getUniqueId().equals(ownerId)).findFirst(); - if (instanceOpt.isPresent()) { - substitutedName.append(instanceOpt.get().getNormalizedName()).append(PATH_DELIMITER); - ToscaElement getOriginRes = getOriginComponent(componentsCache, instanceOpt.get(), originGetter); - appendNameRecursively(componentsCache, getOriginRes, instanceIdIter, substitutedName, originGetter); - } else if (MapUtils.isNotEmpty(((TopologyTemplate) originComponent).getGroups())) { - Optional groupOpt = ((TopologyTemplate) originComponent).getGroups().values().stream().filter(g -> g.getUniqueId().equals(ownerId)).findFirst(); - groupOpt.ifPresent(groupDataDefinition -> substitutedName.append(groupDataDefinition.getName()).append(PATH_DELIMITER)); - } else { - log.debug("Failed to find an capability owner with uniqueId {} on a component with uniqueId {}", ownerId, originComponent.getUniqueId()); - } - } - } - - private static List getReducedPathByOwner(List path, String ownerId) { - log.debug("ownerId {}, path {} ", ownerId, path); - if (CollectionUtils.isEmpty(path)) { - log.debug("cannot perform reduce by owner, path to component is empty"); - return path; - } - if (isBlank(ownerId)) { - log.debug("cannot perform reduce by owner, component owner is empty"); - return path; - } - //reduce by owner - Map map = path.stream().collect(Collectors.toMap(it -> dropLast(it, PATH_DELIMITER), Function.identity(), (a, b) -> a.endsWith(ownerId) ? a : b)); - //reduce list&duplicates and preserve order - return path.stream().distinct().filter(it -> map.values().contains(it)).collect(Collectors.toList()); - } - - private static String dropLast(String path, String delimiter) { - if (isBlank(path) || isBlank(delimiter)) { - return path; - } - return path.substring(0, path.lastIndexOf(delimiter)); - } -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapper.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapper.java deleted file mode 100644 index 2c3c98e133..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapper.java +++ /dev/null @@ -1,53 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.utils; - -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.model.jsontitan.operations.ExternalReferencesOperation; -import org.openecomp.sdc.common.log.wrappers.Logger; -import org.springframework.stereotype.Component; - -import java.util.Map; -import java.util.Optional; - -/** - * Created by yavivi on 12/02/2018. - */ -@Component -public class IdMapper { - - private static final Logger log = Logger.getLogger(ExternalReferencesOperation.class.getName()); - - public String mapComponentNameToUniqueId(String componentInstanceName, GraphVertex serviceVertex) { - return map(componentInstanceName, serviceVertex, true); - } - - public String mapUniqueIdToComponentNameTo(String compUniqueId, GraphVertex serviceVertex) { - return map(compUniqueId, serviceVertex, false); - } - - private String map(String componentUniqueIdOrName, GraphVertex serviceVertex, boolean fromCompName) { - String result = null; - try { - Map jsonComposition = (Map) serviceVertex.getJson(); - CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - - Optional componentInstanceDataDefinitionOptional = null; - if (fromCompName) { - componentInstanceDataDefinitionOptional = compositionDataDefinition.getComponentInstances().values().stream().filter(c -> c.getNormalizedName().equals(componentUniqueIdOrName)).findAny(); - result = componentInstanceDataDefinitionOptional.get().getUniqueId(); - log.debug("Compponent Instance Unique Id = {}", result); - } else { - componentInstanceDataDefinitionOptional = compositionDataDefinition.getComponentInstances().values().stream().filter(c -> c.getUniqueId().equals(componentUniqueIdOrName)).findAny(); - result = componentInstanceDataDefinitionOptional.get().getNormalizedName(); - log.debug("Compponent Instance Normalized Name = {}", result); - } - - } catch (Exception e) { - log.error("Failed to map UUID or Normalized name of " + componentUniqueIdOrName, e); - } - return result; - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java deleted file mode 100644 index 9412c5c70b..0000000000 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java +++ /dev/null @@ -1,1731 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.T - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.utils; - -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.collections.ListUtils; -import org.apache.commons.collections.MapUtils; -import org.apache.commons.lang.BooleanUtils; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.builder.ReflectionToStringBuilder; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.*; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.resources.data.ComponentMetadataData; -import org.openecomp.sdc.be.resources.data.ProductMetadataData; -import org.openecomp.sdc.be.resources.data.ResourceMetadataData; -import org.openecomp.sdc.be.resources.data.ServiceMetadataData; -import org.openecomp.sdc.common.log.wrappers.Logger; - -import java.util.*; -import java.util.Map.Entry; -import java.util.function.Function; -import java.util.stream.Collectors; - -public class ModelConverter { - public static final String CAP_PROP_DELIM = "#"; - private static final Logger log = Logger.getLogger(ModelConverter.class); - - @SuppressWarnings("unchecked") - public static T convertToToscaElement(Component component) { - if (isAtomicComponent(component)) { - return (T) convertToNodeType(component); - } - return (T) convertToTopologyTemplate(component); - } - - @SuppressWarnings("unchecked") - public static T convertFromToscaElement(ToscaElement toscaElement) { - switch (toscaElement.getComponentType()) { - case RESOURCE: - return (T) convertToResource(toscaElement); - case SERVICE: - case PRODUCT: - return (T) convertToService(toscaElement); - default: - return null; - } - } - - public static boolean isAtomicComponent(Component component) { - ComponentTypeEnum componentType = component.getComponentType(); - if (!componentType.equals(ComponentTypeEnum.RESOURCE)) { - return false; - } - Resource resource = (Resource) component; - ResourceTypeEnum resType = resource.getResourceType(); - return isAtomicComponent(resType); - } - - public static boolean isAtomicComponent(ResourceTypeEnum resourceType) { - if (resourceType == null) { - return false; - } - return resourceType.isAtomicType(); - } - - // ********************************************************** - public static VertexTypeEnum getVertexType(Component component) { - VertexTypeEnum vertexType; - if (isAtomicComponent(component)) { - vertexType = VertexTypeEnum.NODE_TYPE; - } else { - vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE; - } - return vertexType; - } - - public static VertexTypeEnum getVertexType(String resourceTypeName) { - VertexTypeEnum vertexType = null; - ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName); - if (isAtomicComponent(resourceType)) { - vertexType = VertexTypeEnum.NODE_TYPE; - } else { - vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE; - } - return vertexType; - } - - - - private static Service convertToService(ToscaElement toscaElement) { - Service service = new Service(); - convertComponentFields(service, toscaElement); - - convertServiceSpecificFields(toscaElement, service); - - TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; - - convertComponentInstances(topologyTemplate, service); - - convertInputs(topologyTemplate, service); - - convertProperties(topologyTemplate, service); - - convertPolicies(topologyTemplate, service); - - convertProperties(topologyTemplate, service); - - convertPolicies(topologyTemplate, service); - - convertGroups(topologyTemplate, service); - - setCapabilitiesToComponentAndGroups(topologyTemplate, service); - - convertPolicies(topologyTemplate, service); - - convertRelations(topologyTemplate, service); - - convertArtifacts(topologyTemplate, service); - - convertServiceApiArtifacts(topologyTemplate, service); - - convertServicePaths(topologyTemplate, service); - - convertServiceInterfaces(topologyTemplate, service); - - convertDataTypes(topologyTemplate, service); - - convertNodeFiltersComponents(topologyTemplate, service); - setCapabilitiesToComponent(topologyTemplate, service); - setRequirementsToComponent(topologyTemplate, service); - return service; - } - - private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) { - service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE)); - service.setDistributionStatus(DistributionStatusEnum - .findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS))); - service.setEcompGeneratedNaming( - (Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true)); - service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, - StringUtils.EMPTY)); - service.setEnvironmentContext( - (String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT)); - service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY)); - } - - private static Resource convertToResource(ToscaElement toscaElement) { - Resource resource = new Resource(); - convertComponentFields(resource, toscaElement); - - resource.setResourceType(toscaElement.getResourceType()); - if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) { - NodeType nodeType = (NodeType) toscaElement; - resource.setDerivedFrom(nodeType.getDerivedFrom()); - resource.setDerivedList(nodeType.getDerivedList()); - resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); - convertAttributes(nodeType, resource); - convertCapabilities(nodeType, resource); - convertRequirements(nodeType, resource); - convertInterfaces(nodeType, resource); - - } else { - TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement; - if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) { - resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID)); - resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION)); - resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM)); - convertInterfaces(topologyTemplate, resource); - - } - convertComponentInstances(topologyTemplate, resource); - convertRelations(topologyTemplate, resource); - convertInputs(topologyTemplate, resource); - convertGroups(topologyTemplate, resource); - setCapabilitiesToComponentAndGroups(topologyTemplate, resource); - convertPolicies(topologyTemplate, resource); - convertNodeFiltersComponents(topologyTemplate, resource); - convertProperties(topologyTemplate, resource); - setCapabilitiesToComponent(topologyTemplate, resource); - setRequirementsToComponent(topologyTemplate, resource); - convertDataTypes(topologyTemplate, resource); - } - convertArtifacts(toscaElement, resource); - convertAdditionalInformation(toscaElement, resource); - - return resource; - } - - private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) { - Map interfaces = toscaElement.getInterfaces(); - Map copy; - if (interfaces != null) { - copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue()))); - } else { - copy = new HashMap<>(); - } - resource.setInterfaces(copy); - } - - private static void convertServiceInterfaces(TopologyTemplate toscaElement, Service service) { - Map interfaces = toscaElement.getInterfaces(); - Map copy; - if (interfaces != null) { - copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue()))); - } else { - copy = new HashMap<>(); - } - service.setInterfaces(copy); - } - - private static void convertAttributes(NodeType nodeType, Resource resource) { - Map attributes = nodeType.getAttributes(); - if (attributes != null) { - List attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList()); - resource.setAttributes(attrs); - } - } - - private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) { - PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition); - attributeDefinition.setParentUniqueId(resourceId); - return attributeDefinition; - } - - private static void convertInterfaces(NodeType nodeType, Resource resource) { - Map interfaceArtifacts = nodeType.getInterfaceArtifacts(); - if (interfaceArtifacts != null) { - Map interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue()))); - resource.setInterfaces(interfaces); - } - } - - /** - * Converts component instances of topology template to component instances of resource - * - * @param topologyTemplate - * @param component - */ - public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) { - - if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) { - - setComponentInstancesAttributesToComponent(topologyTemplate, component); - - setComponentInstancesPropertiesToComponent(topologyTemplate, component); - - setComponentInstancesInputsToComponent(topologyTemplate, component); - - setComponentInstancesToComponent(topologyTemplate, component); - - setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component); - - setComponentInstancesRequirementsToComponent(topologyTemplate, component); - - setComponentInstancesArtifactsToComponent(topologyTemplate, component); - - setComponentInstancesInterfacesToComponent(topologyTemplate, component); - - } - } - - private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) { - Map instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts(); - Map instanceArtifacts = topologyTemplate.getInstanceArtifacts(); - - List instances = component.getComponentInstances(); - if (instDeploymentArtifacts != null && instances != null) { - instDeploymentArtifacts.entrySet().forEach(e -> { - Optional ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst(); - if (ci.isPresent()) { - Map mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition(); - Map deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue()))); - - ci.get().setDeploymentArtifacts(deplArt); - } - }); - } - if (instanceArtifacts != null && instances != null) { - instanceArtifacts.entrySet().forEach(e -> { - Optional ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst(); - if (ci.isPresent()) { - Map mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition(); - Map deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue()))); - - ci.get().setArtifacts(deplArt); - } - }); - } - - } - - public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) { - - if (!CollectionUtils.isEmpty(component.getComponentInstances())) { - - setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate); - - setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate); - - setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate); - - setComponentInstancesToTopologyTemplate(component, topologyTemplate); - - setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate); - } - } - - public static void convertRelations(TopologyTemplate topologyTemplate, Component component) { - Map relations = topologyTemplate.getRelations(); - List componentRelations; - if (relations != null && !relations.isEmpty()) { - componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList()); - - } else { - componentRelations = new ArrayList<>(); - } - component.setComponentInstancesRelations(componentRelations); - - } - - public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) { - RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef(); - requirementCapabilityRelDef.setFromNode(relation.getFromId()); - requirementCapabilityRelDef.setToNode(relation.getToId()); - requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI())); - - CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship(); - RelationshipInfo relationshipPair = getRelationshipInfo(relation); - rel.setRelation(relationshipPair); - requirementCapabilityRelDef.setRelationships(Arrays.asList(rel)); - - return requirementCapabilityRelDef; - } - - /** - * @param relation - * @return - */ - private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) { - RelationshipInfo relationshipPair = new RelationshipInfo(); - - relationshipPair.setId(relation.getUniqueId()); - - relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId()); - relationshipPair.setCapabilityUid(relation.getCapabilityId()); - relationshipPair.setCapability(relation.getCapability()); - - relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId()); - relationshipPair.setRequirementUid(relation.getRequirementId()); - relationshipPair.setRequirement(relation.getRequirement()); - - RelationshipImpl relationship = new RelationshipImpl(); - relationship.setType(relation.getType()); - relationshipPair.setRelationships(relationship); - - return relationshipPair; - } - - - public static List convertRelationToToscaRelation(RequirementCapabilityRelDef relation) { - - List relationsList = new ArrayList<>(); - - List relationship = relation.getRelationships(); - relationship.forEach(p -> { - RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition(); - requirementCapabilityRelDef.setFromId(relation.getFromNode()); - requirementCapabilityRelDef.setToId(relation.getToNode()); - requirementCapabilityRelDef.setUniqueId(p.getRelation().getId()); - requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId()); - requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid()); - requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId()); - requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid()); - requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement()); - requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType()); - requirementCapabilityRelDef.setCapability(p.getRelation().getCapability()); - - relationsList.add(requirementCapabilityRelDef); - }); - - return relationsList; - } - - private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) { - convertTopologyTemplateCapabilities(component, topologyTemplate); - if(componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)){ - topologyTemplate.setCalculatedCapabilities(new HashMap<>()); - topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>()); - } - convertComponentInstancesCapabilities(component, topologyTemplate); - convertGroupsCapabilities(component, topologyTemplate); - } - - private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) { - if(groupsCapabilitiesExist(component)){ - component.getGroups() - .stream() - .filter(g -> MapUtils.isNotEmpty(g.getCapabilities())) - .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId())); - } - } - - private static void convertTopologyTemplateCapabilities(Component component, ToscaElement toscaElement) { - Map> capabilities = component.getCapabilities(); - - Map toscaCapMap = new HashMap<>(); - Map toscaCapPropMap = new HashMap<>(); - - if (MapUtils.isNotEmpty(capabilities )) { - capabilities.forEach((s, caps) -> { - if (CollectionUtils.isNotEmpty(caps)) { - List capList = caps.stream().filter(capabilityDefinition -> capabilityDefinition.getOwnerId() - .equals(component.getUniqueId())).map(CapabilityDataDefinition::new).collect(Collectors.toList()); - - populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList); - } - } - ); - - toscaElement.setCapabilities(toscaCapMap); - toscaElement.setCapabilitiesProperties(toscaCapPropMap); - } - } - private static void populateCapabilityMap(Map toscaCapMap, - Map toscaCapPropMap, - String s, List caps, - List capList) { - ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList); - toscaCapMap.put(s, listCapabilityDataDefinition); - - for (CapabilityDefinition cap : caps) { - List capPrps = cap.getProperties(); - if (CollectionUtils.isNotEmpty(capPrps)) { - MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - for (ComponentInstanceProperty cip : capPrps) { - PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip); - propertyDataDefinition.setParentUniqueId(cap.getUniqueId()); - dataToCreate.put(cip.getName(), propertyDataDefinition); - } - toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate); - } - } - } - - private static void convertTopologyTemplateRequirements(Component component, ToscaElement toscaElement) { - Map> requirements = component.getRequirements(); - - Map toscaReqMap = new HashMap<>(); - - if (MapUtils.isNotEmpty(requirements )) { - requirements.forEach((s, reqs)-> { - if (CollectionUtils.isNotEmpty(reqs)) { - List reqList = reqs.stream().filter(requirementDefinition -> requirementDefinition.getOwnerId() - .equals(component.getUniqueId())).map(RequirementDataDefinition::new).collect(Collectors.toList()); - - ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList); - toscaReqMap.put(s, listRequirementDataDefinition); - } - } - ); - toscaElement.setRequirements(toscaReqMap); - } - } - private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) { - if (componentInstancesCapabilitiesExist(component)) { - component.getComponentInstances() - .stream() - .filter(i -> MapUtils.isNotEmpty(i.getCapabilities())) - .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId())); - } - } - - private static void addCapabilities(TopologyTemplate topologyTemplate, Map> capabilities, String ownerId) { - if (MapUtils.isNotEmpty(capabilities)) { - if (topologyTemplate.getCalculatedCapabilities() == null) { - topologyTemplate.setCalculatedCapabilities(new HashMap<>()); - } - topologyTemplate.getCalculatedCapabilities().put(ownerId, convertToMapListCapabiltyDataDefinition(capabilities)); - if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) { - topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>()); - } - topologyTemplate.getCalculatedCapabilitiesProperties().put(ownerId, convertToMapOfMapCapabiltyProperties(capabilities, ownerId)); - } - } - - private static boolean componentInstancesCapabilitiesExist(Component component) { - return component.getCapabilities() != null && component.getComponentInstances() != null - && component.getComponentInstances() - .stream() - .filter(ci->MapUtils.isNotEmpty(ci.getCapabilities())) - .findFirst() - .isPresent(); - } - private static boolean groupsCapabilitiesExist(Component component) { - return component.getCapabilities() != null && component.getGroups() != null - && component.getGroups() - .stream() - .filter(g->MapUtils.isNotEmpty(g.getCapabilities())) - .findFirst() - .isPresent(); - } - public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map> instCapabilities, String ownerId) { - return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false); - } - - public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map> capabilities, String ownerId, boolean fromCsar) { - - Map toscaCapPropMap = new HashMap<>(); - if(MapUtils.isNotEmpty(capabilities)) - capabilities.forEach((s, caps)-> { - - if (caps != null && !caps.isEmpty()) { - - MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - - for (CapabilityDefinition cap : caps) { - List capPrps = cap.getProperties(); - if (capPrps != null) { - - for (ComponentInstanceProperty cip : capPrps) { - dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip)); - } - // format key of capability properties : - // VF instance in service : instanceId#ownerId#type#capName - // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId - - StringBuilder sb = new StringBuilder(ownerId); - sb.append(CAP_PROP_DELIM); - if (fromCsar) { - sb.append(ownerId); - } else { - sb.append(cap.getOwnerId()); - } - sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName()); - toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate)); - } - } - } - } - ); - return new MapCapabilityProperty(toscaCapPropMap); - } - - private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map> instCapabilities) { - - Map mapToscaDataDefinition = new HashMap<>(); - for (Entry> instCapability : instCapabilities.entrySet()) { - mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))); - } - - return new MapListCapabilityDataDefinition(mapToscaDataDefinition); - } - - private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) { - - convertTopologyTemplateRequirements(component, topologyTemplate); - if (component.getRequirements() != null && component.getComponentInstances() != null) { - topologyTemplate.setCalculatedRequirements(new HashMap<>()); - for (ComponentInstance instance : component.getComponentInstances()) { - Map> instRequirements = instance.getRequirements(); - if (MapUtils.isNotEmpty(instRequirements)) { - if (topologyTemplate.getCalculatedRequirements() == null) { - topologyTemplate.setCalculatedRequirements(new HashMap<>()); - } - topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements)); - } - } - } - } - - private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map> instRequirements) { - - Map mapToscaDataDefinition = new HashMap<>(); - for (Entry> instRequirement : instRequirements.entrySet()) { - mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList()))); - } - - return new MapListRequirementDataDefinition(mapToscaDataDefinition); - } - - @SuppressWarnings("unchecked") - private static void convertComponentFields(Component component, ToscaElement toscaElement) { - component.setName(toscaElement.getName()); - component.setAllVersions(toscaElement.getAllVersions()); - component.setCategories(toscaElement.getCategories()); - component.setComponentType(toscaElement.getComponentType()); - component.setCreationDate(toscaElement.getCreationDate()); - component.setCreatorUserId(toscaElement.getCreatorUserId()); - component.setCreatorFullName(toscaElement.getCreatorFullName()); - component.setLastUpdateDate(toscaElement.getLastUpdateDate()); - component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName()); - component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId()); - component.setNormalizedName(toscaElement.getNormalizedName()); - - component.setLifecycleState(toscaElement.getLifecycleState()); - component.setVersion(toscaElement.getVersion()); - component.setHighestVersion(toscaElement.isHighestVersion()); - component.setUniqueId(toscaElement.getUniqueId()); - component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME)); - component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType()); - component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion()); - - Map properties = toscaElement.getProperties(); - if(MapUtils.isNotEmpty(properties)) { - List propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList()); - component.setProperties(propertiesMap); - } - - //archive - component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived()); - - - //component.setArchiveTime(toscaElement.getArchiveTime() == null ? 0L : toscaElement.getArchiveTime()); - component.setArchiveTime(toscaElement.getArchiveTime()); - component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived()); - - if (component.getComponentType() == ComponentTypeEnum.RESOURCE) { - Resource resource = (Resource) component; - resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT)); - resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME)); - resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME)); - resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE)); - // field isn't mandatory , but shouldn't be null(should be an empty string instead) - if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){ - resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)); - } else { - resource.setResourceVendorModelNumber(""); - } - } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) { - Service service = (Service) component; - if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){ - service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)); - } else { - service.setServiceType(""); - } - if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){ - service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)); - } else { - service.setServiceRole(""); - } - } - component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL)); - component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON)); - component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION)); - component.setTags((List) toscaElement.getMetadataValue(JsonPresentationFields.TAGS)); - component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID)); - component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID)); - component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID)); - component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED)); - component.setToscaType(toscaElement.getToscaType().getValue()); - } - - private static NodeType convertToNodeType(Component component) { - Resource resource = (Resource) component; - NodeType nodeType = new NodeType(); - nodeType.setDerivedFrom(resource.getDerivedFrom()); - nodeType.setDerivedList(resource.getDerivedList()); - nodeType.setResourceType(resource.getResourceType()); - convertCommonToscaData(component, nodeType); - convertAdditionalInformation(component, nodeType); - convertArtifacts(resource, nodeType); - convertCapabilities(resource, nodeType); - convertRequirements(resource, nodeType); - convertAttributes(resource, nodeType); - convertProperties(resource, nodeType); - convertInterfaces(resource, nodeType); - return nodeType; - } - - private static void convertProperties(Resource resource, NodeType nodeType) { - List properties = resource.getProperties(); - if (properties != null && !properties.isEmpty()) { - Map propertiesMap = properties.stream().collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new)); - nodeType.setProperties(propertiesMap); - } - } - - private static void convertInterfaces(Resource resource, NodeType nodeType) { - Map interfaces = resource.getInterfaces(); - if (interfaces != null) { - Map interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue()))); - nodeType.setInterfaceArtifacts(interfaceArtifacts); - } - } - - private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) { - List additionalInformation = component.getAdditionalInformation(); - if (additionalInformation != null) { - Map addInfo = additionalInformation.stream().collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new)); - toscaElement.setAdditionalInformation(addInfo); - } - } - - private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) { - Map additionalInformation = toscaElement.getAdditionalInformation(); - if (additionalInformation != null) { - List addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new).collect(Collectors.toList()); - resource.setAdditionalInformation(addInfo); - } - } - - private static void convertArtifacts(ToscaElement toscaElement, Component component) { - Map artifacts = toscaElement.getArtifacts(); - Map copy; - if (artifacts != null) { - copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); - - } else { - copy = new HashMap<>(); - } - component.setArtifacts(copy); - - Map toscaArtifacts = toscaElement.getToscaArtifacts(); - if (toscaArtifacts != null) { - copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); - - } else { - copy = new HashMap<>(); - } - component.setToscaArtifacts(copy); - - Map deploymentArtifacts = toscaElement.getDeploymentArtifacts(); - if (deploymentArtifacts != null) { - copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); - - } else { - copy = new HashMap<>(); - } - component.setDeploymentArtifacts(copy); - } - - private static void convertNodeFiltersComponents(TopologyTemplate topologyTemplate, Component component) { - Map filters = topologyTemplate.getNodeFilterComponents(); - Map copy; - if (filters != null) { - copy = filters.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new CINodeFilterDataDefinition(e.getValue()))); - } else { - copy = new HashMap<>(); - } - component.setNodeFilterComponents(copy); - } - - private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) { - Map serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts(); - Map copy; - if (serviceApiArtifacts != null) { - copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue()))); - - } else { - copy = new HashMap<>(); - } - service.setServiceApiArtifacts(copy); - } - private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) { - Map servicePaths = topologyTemplate.getForwardingPaths(); - Map copy; - if (servicePaths != null) { - copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue()))); - - } else { - copy = new HashMap<>(); - } - service.setForwardingPaths(copy); - } - - private static void convertArtifacts(Component component, ToscaElement toscaElement) { - Map artifacts = component.getArtifacts(); - if (artifacts != null) { - Map copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - toscaElement.setArtifacts(copy); - } - - Map toscaArtifacts = component.getToscaArtifacts(); - if (toscaArtifacts != null) { - Map copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - toscaElement.setToscaArtifacts(copy); - } - - Map deploymentArtifacts = component.getDeploymentArtifacts(); - if (deploymentArtifacts != null) { - Map copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - toscaElement.setDeploymentArtifacts(copy); - } - } - - private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) { - Map serviceApiArtifacts = service.getServiceApiArtifacts(); - if (serviceApiArtifacts != null) { - Map copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - topologyTemplate.setServiceApiArtifacts(copy); - } - } - - private static void convertCapabilities(Component component, NodeType toscaElement) { - Map> capabilities = component.getCapabilities(); - - Map toscaCapMap = new HashMap<>(); - Map toscaCapPropMap = new HashMap<>(); - - if (capabilities != null && !capabilities.isEmpty()) { - capabilities.forEach((s, caps) -> { - - if (caps != null && !caps.isEmpty()) { - List capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()); - - populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList); - } - } - ); - - toscaElement.setCapabilities(toscaCapMap); - toscaElement.setCapabilitiesProperties(toscaCapPropMap); - } - } - - private static void convertAttributes(Resource component, NodeType nodeType) { - List attributes = component.getAttributes(); - if (attributes != null) { - Map attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())); - nodeType.setAttributes(attrsByName); - } - } - - private static void convertRequirements(Resource component, NodeType nodeType) { - Map> requirements = component.getRequirements(); - - Map toscaReqMap = new HashMap<>(); - - if (requirements != null && !requirements.isEmpty()) { - requirements.forEach((s, reqs)-> { - - if (reqs != null && !reqs.isEmpty()) { - List reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList()); - - ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList); - toscaReqMap.put(s, listRequirementDataDefinition); - } - } - ); - nodeType.setRequirements(toscaReqMap); - } - } - - private static void convertCapabilities(NodeType toscaElement, Component component) { - Map toscaCapabilities = toscaElement.getCapabilities(); - Map toscaCapPropMap = toscaElement.getCapabilitiesProperties(); - - Map> compCap = new HashMap<>(); - if (toscaCapabilities == null || toscaCapabilities.isEmpty()) - return; - toscaCapabilities.forEach((s, cap)-> { - - if (cap != null) { - List capDataList = cap.getListToscaDataDefinition(); - - if (capDataList != null && !capDataList.isEmpty()) { - List capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList()); - compCap.put(s, capList); - } - } - - } - ); - if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) { - toscaCapPropMap.forEach((s, capProp)-> { - String[] result = s.split(CAP_PROP_DELIM); - if (capProp != null) { - Map capMap = capProp.getMapToscaDataDefinition(); - - if (capMap != null && !capMap.isEmpty()) { - List capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()); - - List cap = compCap.get(result[0]); - Optional op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst(); - if (op.isPresent()) { - op.get().setProperties(capPropsList); - } - } - } - } - ); - } - - component.setCapabilities(compCap); - - } - - private static void convertGroups(TopologyTemplate toscaElement, Component component) { - Map toscaGroups = toscaElement.getGroups(); - List groupDefinitions = null; - if (MapUtils.isNotEmpty(toscaGroups)) { - groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList()); - } - component.setGroups(groupDefinitions); - } - - private static void convertPolicies(TopologyTemplate toscaElement, Component component) { - Map policies = toscaElement.getPolicies(); - Map policyDefinitions = null; - if (MapUtils.isNotEmpty(policies)) { - policyDefinitions = policies.values().stream().map(PolicyDefinition::new).collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity())); - } - component.setPolicies(policyDefinitions); - } - - private static void convertGroups(Component component, TopologyTemplate toscaElement) { - List groupDefinitions = component.getGroups(); - Map groups = new HashMap<>(); - - if (groupDefinitions != null && groups.isEmpty()) { - groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getName, GroupDefinition::new)); - } - toscaElement.setGroups(groups); - } - - private static void convertPolicies(Component component, TopologyTemplate toscaElement) { - Map policyDefinitions = component.getPolicies(); - Map policies = new HashMap<>(); - if (MapUtils.isNotEmpty(policyDefinitions)) { - policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new))); - } - toscaElement.setPolicies(policies); - } - - private static void convertRequirements(NodeType toscaElement, Component component) { - Map toscaRequirements = toscaElement.getRequirements(); - - Map> compReqs = new HashMap<>(); - if (toscaRequirements == null || toscaRequirements.isEmpty()) - return; - toscaRequirements.forEach((s, req) -> { - - if (req != null) { - List reqDataList = req.getListToscaDataDefinition(); - - if (reqDataList != null && !reqDataList.isEmpty()) { - List reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList()); - compReqs.put(s, reqList); - } - } - } - ); - component.setRequirements(compReqs); - } - - private static TopologyTemplate convertToTopologyTemplate(Component component) { - TopologyTemplate topologyTemplate; - ComponentTypeEnum componentType = component.getComponentType(); - topologyTemplate = new TopologyTemplate(); - - if (componentType == ComponentTypeEnum.RESOURCE) { - Resource resource = (Resource) component; - topologyTemplate.setResourceType(resource.getResourceType()); - topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID()); - topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion()); - topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum()); - convertTopologyTemplateInterfaces(resource, topologyTemplate); - } - if (componentType == ComponentTypeEnum.SERVICE) { - convertServiceSpecificEntities((Service) component, topologyTemplate); - } - convertCommonToscaData(component, topologyTemplate); - convertArtifacts(component, topologyTemplate); - - convertAdditionalInformation(component, topologyTemplate); - convertComponentInstances(component, topologyTemplate); - - convertInputs(component, topologyTemplate); - convertProperties(component, topologyTemplate); - convertCapabilities(component, topologyTemplate); - convertGroups(component, topologyTemplate); - convertPolicies(component, topologyTemplate); - convertRequirements(component, topologyTemplate); - convertRelationsToComposition(component, topologyTemplate); - - return topologyTemplate; - } - - private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) { - Map interfaces = resource.getInterfaces(); - if (interfaces != null && !interfaces.isEmpty()) { - Map copy = interfaces.entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue()))); - topologyTemplate.setInterfaces(copy); - } - } - - private static void convertServiceInterfaces(Service service, TopologyTemplate topologyTemplate) { - Map interfaces = service.getInterfaces(); - if (interfaces != null && !interfaces.isEmpty()) { - Map copy = interfaces.entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue()))); - topologyTemplate.setInterfaces(copy); - } - } - - private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) { - convertServiceMetaData(service, topologyTemplate); - convertServiceApiArtifacts(service, topologyTemplate); - convertServicePaths(service,topologyTemplate); - convertServiceInterfaces(service, topologyTemplate); - } - - private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) { - Map servicePaths = service.getForwardingPaths(); - if (servicePaths != null && !servicePaths.isEmpty()) { - Map copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue()))); - topologyTemplate.setForwardingPaths(copy); - } - } - - private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) { - if (service.getDistributionStatus() != null) { - topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, - service.getDistributionStatus().name()); - } - topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode()); - topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, - service.isEcompGeneratedNaming()); - topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy()); - topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext()); - topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType()); - - } - - private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) { - List componentInstancesRelations = component.getComponentInstancesRelations(); - if (componentInstancesRelations != null) { - Map compositions = topologyTemplate.getCompositions(); - if (compositions == null) { - compositions = new HashMap<>(); - } - CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - if (compositionDataDefinition == null) { - compositionDataDefinition = new CompositionDataDefinition(); - compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition); - } - - Map relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null) - .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity())); - compositionDataDefinition.setRelations(relations); - } - } - - private static void convertInputs(Component component, TopologyTemplate topologyTemplate) { - List inputsList = component.getInputs(); - if (inputsList != null && !inputsList.isEmpty()) { - - Map inputsMap = inputsList.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())); - topologyTemplate.setInputs(inputsMap); - } - - } - - private static void convertInputs(TopologyTemplate topologyTemplate, Component component) { - Map inputsMap = topologyTemplate.getInputs(); - if (inputsMap != null && !inputsMap.isEmpty()) { - List inputsList = inputsMap.values() - .stream() - .map(InputDefinition::new) - .collect(Collectors.toList()); - component.setInputs(inputsList); - } - } - - private static void convertProperties(Component component, TopologyTemplate topologyTemplate) { - List propertiesList = component.getProperties(); - if (propertiesList != null && !propertiesList.isEmpty()) { - Map propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i)).collect(Collectors.toMap(i -> i.getName(), i -> i)); - topologyTemplate.setProperties(propertiesMap); - } - - } - - private static void convertProperties(TopologyTemplate topologyTemplate, Component component) { - Map proeprtiesMap = topologyTemplate.getProperties(); - if (proeprtiesMap != null && !proeprtiesMap.isEmpty()) { - Map copy = proeprtiesMap.entrySet().stream() - .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition - (entry.getValue()))); - component.setProperties(new ArrayList<>(copy.values())); - } - } - - private static void convertDataTypes(TopologyTemplate topologyTemplate, Component component) { - Map dataTypeDataMap = topologyTemplate.getDataTypes(); - if (MapUtils.isNotEmpty(dataTypeDataMap)) { - List dataTypeMap = dataTypeDataMap.values().stream().map(e -> { - DataTypeDefinition dataType = new DataTypeDefinition(e); - - if(CollectionUtils.isNotEmpty(e.getPropertiesData())) { - log.debug("#convertDataTypes - propertiesData is not null. {}", - ReflectionToStringBuilder.toString(e.getPropertiesData())); - dataType.setProperties(e.getPropertiesData().stream() - .map(PropertyDefinition::new).collect(Collectors.toList())); - } else { - log.debug("#convertDataTypes - propertiesData is null. ignore."); - } - return dataType; - }).collect(Collectors.toList()); - component.setDataTypes(dataTypeMap); - } - } - - - private static void convertCommonToscaData(Component component, ToscaElement toscaElement) { - toscaElement.setUUID(component.getUUID()); - toscaElement.setUniqueId(component.getUniqueId()); - toscaElement.setSystemName(component.getSystemName()); - toscaElement.setLifecycleState(component.getLifecycleState()); - toscaElement.setComponentType(component.getComponentType()); - toscaElement.setNormalizedName(component.getNormalizedName()); - toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName()); - toscaElement.setCategories(component.getCategories()); - toscaElement.setCreatorUserId(component.getCreatorUserId()); - toscaElement.setCreationDate(component.getCreationDate()); - toscaElement.setCreatorFullName(component.getCreatorFullName()); - toscaElement.setHighestVersion(component.isHighestVersion()); - toscaElement.setLastUpdateDate(component.getLastUpdateDate()); - toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName()); - toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId()); - toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType()); - toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion()); - - //Archive - toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived()); - toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime()); - toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived()); - - toscaElement.setLifecycleState(component.getLifecycleState()); - toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion()); - if (component.getComponentType() == ComponentTypeEnum.RESOURCE) { - toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract()); - toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName()); - toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName()); - toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease()); - // field isn't mandatory , but shouldn't be null(should be an empty string instead) - if (((Resource) component).getResourceVendorModelNumber() != null){ - toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber()); - } else { - toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ""); - } - } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) { - // field isn't mandatory , but shouldn't be null(should be an empty string instead) - if (((Service) component).getServiceType() != null){ - toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType()); - } else { - toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ""); - } - if (((Service) component).getServiceRole() != null){ - toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole()); - } else { - toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ""); - } - } - toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel()); - toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted()); - toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon()); - toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription()); - toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags()); - toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID()); - toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId()); - } - - - - - private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) { - - List componentInstances = new ArrayList<>(); - ComponentInstance currComponentInstance; - Map nodeFilterComponents = topologyTemplate.getNodeFilterComponents(); - - for (Map.Entry entry : topologyTemplate.getComponentInstances().entrySet()) { - String key = entry.getKey(); - currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key)); - if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) { - List groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList()); - currComponentInstance.setGroupInstances(groupInstances); - } - if(nodeFilterComponents != null && nodeFilterComponents.containsKey(key)){ - currComponentInstance.setNodeFilter(nodeFilterComponents.get(key)); - } - if(topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key) && topologyTemplate.getInstProperties().get(key) != null ){ - List instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList()); - currComponentInstance.setProperties(instanceProps); - } - if(topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key) && topologyTemplate.getInstInputs().get(key) != null ){ - List instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList()); - currComponentInstance.setInputs(instanceInputs); - } - if(topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key) && topologyTemplate.getComponentInstInterfaces().get(key) != null ){ - Map interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); - currComponentInstance.setInterfaces(interfacesMap); - } - componentInstances.add(currComponentInstance); - - } - component.setComponentInstances(componentInstances); - } - - private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) { - if (topologyTemplate.getInstInputs() != null) { - Map> inputs = new HashMap<>(); - for (Entry entry : topologyTemplate.getInstInputs().entrySet()) { - if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { - String key = entry.getKey(); - List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList()); - inputs.put(key, componentInstanceAttributes); - } - } - component.setComponentInstancesInputs(inputs); - } - } - - private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) { - if (topologyTemplate.getInstProperties() != null) { - Map> properties = new HashMap<>(); - for (Entry entry : topologyTemplate.getInstProperties().entrySet()) { - if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { - String key = entry.getKey(); - List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue()))) - .collect(Collectors.toList()); - properties.put(key, componentInstanceAttributes); - } - } - component.setComponentInstancesProperties(properties); - } - } - - private static void setComponentInstancesInterfacesToComponent(TopologyTemplate topologyTemplate, Component component) { - if (topologyTemplate.getInstInterfaces() != null) { - Map> interfaces = new HashMap<>(); - for (Entry entry : topologyTemplate.getInstInterfaces().entrySet()) { - if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { - String key = entry.getKey(); - List componentInstanceInterfaces = entry.getValue() - .getMapToscaDataDefinition().entrySet().stream().map(e -> new - ComponentInstanceInterface(e.getKey(), e.getValue())) - .collect(Collectors.toList()); - interfaces.put(key, componentInstanceInterfaces); - } - } - component.setComponentInstancesInterfaces(interfaces); - } - else if (topologyTemplate.getComponentInstInterfaces() != null) { - Map> interfaces = new HashMap<>(); - for (Entry entry : topologyTemplate.getComponentInstInterfaces().entrySet()) { - if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { - String key = entry.getKey(); - List componentInstanceInterfaces = entry.getValue() - .getMapToscaDataDefinition().entrySet().stream().map(e -> new - ComponentInstanceInterface(e.getKey(), e.getValue())) - .collect(Collectors.toList()); - interfaces.put(key, componentInstanceInterfaces); - } - } - component.setComponentInstancesInterfaces(interfaces); - } - - } - - private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) { - if (topologyTemplate.getInstAttributes() != null) { - Map> attributes = new HashMap<>(); - for (Map.Entry entry : topologyTemplate.getInstAttributes().entrySet()) { - if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) { - String key = entry.getKey(); - List componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue()))) - .collect(Collectors.toList()); - attributes.put(key, componentInstanceAttributes); - } - } - component.setComponentInstancesAttributes(attributes); - } - } - - private static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) { - - if (topologyTemplate.getCalculatedRequirements() != null) { - // Requirements of component organized by capability - Map> instancesRequirements = new HashMap<>(); - - Map instancesMap = new HashMap<>(); - for (ComponentInstance currInstance : component.getComponentInstances()) { - instancesMap.put(currInstance.getUniqueId(), currInstance); - } - for (Map.Entry entry : topologyTemplate.getCalculatedRequirements().entrySet()) { - - String instanceId = entry.getKey(); - // Requirements of instance organized by capability - Map capsMapList = entry.getValue().getMapToscaDataDefinition(); - - if(capsMapList != null) { - for (Entry entryTypeList : capsMapList.entrySet()) { - String capabilityType = entryTypeList.getKey(); - List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList()); - if (instancesRequirements.containsKey(capabilityType)) { - instancesRequirements.get(capabilityType).addAll(caps); - } else { - instancesRequirements.put(capabilityType, caps); - } - if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) { - instancesMap.get(instanceId).setRequirements(new HashMap<>()); - } - instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps)); - } - } - } - component.setRequirements(instancesRequirements); - } - } - - private static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) { - Map calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties(); - - if (topologyTemplate.getCalculatedCapabilities() != null) { - // capabilities of component organized by type - Map> instancesCapabilities = new HashMap<>(); - - Map instancesMap = new HashMap<>(); - for (ComponentInstance currInstance : component.getComponentInstances()) { - instancesMap.put(currInstance.getUniqueId(), currInstance); - } - for (Map.Entry entry : topologyTemplate.getCalculatedCapabilities().entrySet()) { - - String instanceId = entry.getKey(); - // capabilities of instance organized by type - Map capsMapList = entry.getValue().getMapToscaDataDefinition(); - - if(capsMapList != null) { - for (Entry entryTypeList : capsMapList.entrySet()) { - String capabilityType = entryTypeList.getKey(); - List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList()); - if (instancesCapabilities.containsKey(capabilityType)) { - instancesCapabilities.get(capabilityType).addAll(caps); - } else { - instancesCapabilities.put(capabilityType, caps); - } - ComponentInstance instance = instancesMap.get(instanceId); - if (instance == null) { - log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME)); - } else { - if (MapUtils.isEmpty(instance.getCapabilities())) { - instance.setCapabilities(new HashMap<>()); - } - instance.getCapabilities().put(capabilityType, new ArrayList<>(caps)); - } - } - } - } - component.setCapabilities(instancesCapabilities); - } - } - - private static void setCapabilitiesToComponent(TopologyTemplate topologyTemplate, Component component) { - Map capabilities = topologyTemplate.getCapabilities(); - Map capabilitiesProperties = topologyTemplate.getCapabilitiesProperties(); - Map> allCapabilities = new HashMap<>(); - - if(MapUtils.isNotEmpty(capabilities)) { - allCapabilities.putAll(groupCapabilityByType(capabilities)); - } - - if(MapUtils.isNotEmpty(capabilitiesProperties)) { - capabilitiesProperties.forEach((s, capProp)-> { - String[] result = s.split(CAP_PROP_DELIM); - if (capProp != null) { - Map capMap = capProp.getMapToscaDataDefinition(); - - if (MapUtils.isNotEmpty(capMap)) { - List capPropsList = capMap.values().stream() - .map(ComponentInstanceProperty::new).collect(Collectors.toList()); - - List cap = allCapabilities.get(result[0]); - if (cap !=null) { - Optional op = cap.stream().filter(c -> c.getName() - .equals(result[1])).findFirst(); - op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList)); - } - } - } - } - ); - } - Map> componentCapabilities = component.getCapabilities(); - if(MapUtils.isNotEmpty(componentCapabilities)) { - mergeCapabilityMap(allCapabilities, componentCapabilities); - } - component.setCapabilities(allCapabilities); - } - - private static void mergeCapabilityMap(Map> map1, - Map> map2) { - map1.forEach((key1, val1) -> map2.forEach((key2, val2) -> { - if(key1.equals(key2)) { - val2.addAll(val1); - } - })); - map1.putAll(map2); - } - - private static Map> groupCapabilityByType(Map capabilities) { - Map> groupedCapabilities = new HashMap<>(); - - Set typesSet = new HashSet<>(); - List allCapabilityDefinitions = new ArrayList<>(); - for (Entry capabilitiesEntry : capabilities.entrySet()) { - typesSet.addAll( capabilitiesEntry.getValue().getListToscaDataDefinition() - .stream().map(CapabilityDataDefinition::getType).collect(Collectors.toSet())); - - allCapabilityDefinitions.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition() - .stream().map(CapabilityDefinition::new).collect(Collectors.toList())); - } - - for(String capType : typesSet) { - groupedCapabilities.put(capType, allCapabilityDefinitions.stream() - .filter(capabilityDefinition -> capabilityDefinition.getType() - .equals(capType)).collect(Collectors.toList())); - } - return groupedCapabilities; - } - - private static void setRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) { - Map requirements = topologyTemplate.getRequirements(); - Map> componentRequirements = component.getRequirements(); - if(MapUtils.isNotEmpty(requirements)) { - if(componentRequirements == null) { - componentRequirements = new HashMap<>(); - } - componentRequirements.putAll(groupRequirementByType(requirements)); - component.setRequirements(componentRequirements); - } - } - - private static Map> groupRequirementByType(Map requirements) { - Map> groupedRequirement = new HashMap<>(); - - Set typesSet = new HashSet<>(); - List allRequirements = new ArrayList<>(); - for (Entry requirementsEntry : requirements.entrySet()) { - typesSet.addAll( requirementsEntry.getValue().getListToscaDataDefinition() - .stream().map(RequirementDataDefinition::getCapability).collect(Collectors.toSet())); - - allRequirements.addAll(requirementsEntry.getValue().getListToscaDataDefinition() - .stream().map(RequirementDefinition::new).collect(Collectors.toList())); - } - - for(String capType : typesSet) { - groupedRequirement.put(capType, allRequirements.stream().filter(requirementDefinition -> - requirementDefinition.getCapability().equals(capType)).collect(Collectors.toList())); - } - return groupedRequirement; - - } - - - private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) { - - Map calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties(); - - if (capabilitiesAndGroupsExist(topologyTemplate, component)) { - Map groupsMap = component.getGroups().stream().collect(Collectors.toMap(GroupDefinition::getUniqueId,Function.identity())); - - for (Map.Entry entry : topologyTemplate.getCalculatedCapabilities().entrySet()) { - findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry); - } - } - } - - private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) { - return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups()); - } - - private static void findSetCapabilitiesToComponentAndGroup(Map calculatedCapProperties, Component component, Map groupsMap, Map.Entry entry) { - - String uniqueId = entry.getKey(); - if(groupsMap.containsKey(uniqueId)){ - setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId)); - } else { - log.warn("The group with uniqueId {} was not found", uniqueId); - } - } - - private static void setCapabilitiesToComponentAndGroup(Map calculatedCapProperties, Component component, Map.Entry entry, GroupDefinition group) { - - for (Entry entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) { - String capabilityType = entryTypeList.getKey(); - List caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList()); - if (component.getCapabilities().containsKey(capabilityType)) { - component.getCapabilities().get(capabilityType).addAll(caps); - } else { - component.getCapabilities().put(capabilityType, caps); - } - group.getCapabilities().put(capabilityType, Lists.newArrayList(caps)); - } - } - - private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId, Map calculatedCapProperties) { - CapabilityDefinition capability = new CapabilityDefinition(cap); - if (calculatedCapProperties != null) { - MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId); - if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) { - Map toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition(); - toscaCapPropMap.forEach(( keyPath, capProp)-> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp)); - } - } - return capability; - } - - private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path, MapPropertiesDataDefinition capProp) { - // format key of capability properties : - // VF instance in service : instanceId#ownerId#type#capName - // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId - // Group in service : groupName#ownerId#type#capName - // Group in VF : groupName#type#capName -> groupName=ownerId - String[] result = path.split(CAP_PROP_DELIM); - if (result.length < 4) { - log.debug("wrong key format for capabilty, key {}", capProp); - return; - } - if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) { - capability.setProperties(capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList())); - } - } - - private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp, String[] result) { - return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result); - } - - private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) { - int primaryKeyIndex = 0; - int ownerIndex = 1; - int typeIndex = result.length - 2; - int nameIndex = result.length - 1; - return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && primaryPathKey.equals(result[primaryKeyIndex]); - } - - private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { - - Map componentInstances = new HashMap<>(); - ComponentInstanceDataDefinition convertedInstance; - if (component.getComponentInstances() != null) { - for (ComponentInstance instance : component.getComponentInstances()) { - convertedInstance = new ComponentInstanceDataDefinition(instance); - if (instance.getGroupInstances() != null) { - MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition(); - - groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new).collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity()))); - if (topologyTemplate.getInstGroups() == null) { - topologyTemplate.setInstGroups(new HashMap<>()); - } - topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap); - } - componentInstances.put(instance.getUniqueId(), convertedInstance); - } - } - topologyTemplate.setComponentInstances(componentInstances); - - } - - private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { - - if (component.getComponentInstancesInputs() != null) { - topologyTemplate.setInstInputs(new HashMap<>()); - MapPropertiesDataDefinition inputsMap; - for (Entry> entry : component.getComponentInstancesInputs().entrySet()) { - inputsMap = new MapPropertiesDataDefinition(); - - inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); - - topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap); - } - } - } - - private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { - - if (component.getComponentInstancesProperties() != null) { - topologyTemplate.setInstProperties(new HashMap<>()); - MapPropertiesDataDefinition propertiesMap; - for (Entry> entry : component.getComponentInstancesProperties().entrySet()) { - propertiesMap = new MapPropertiesDataDefinition(); - - propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); - - topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap); - } - } - } - - private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { - - List componentInstances = component.getComponentInstances(); - if (componentInstances != null) { - topologyTemplate.setInstanceArtifacts(new HashMap<>()); - topologyTemplate.setInstDeploymentArtifacts(new HashMap<>()); - - for (ComponentInstance ci : componentInstances) { - Map artifacts = ci.getArtifacts(); - if (artifacts != null) { - Map mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact); - topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact); - } - - Map deplArtifacts = ci.getDeploymentArtifacts(); - if (deplArtifacts != null) { - Map mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue()))); - MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact); - topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact); - } - } - } - } - - private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) { - - if (component.getComponentInstancesAttributes() != null) { - topologyTemplate.setInstAttributes(new HashMap<>()); - MapPropertiesDataDefinition attributesMap; - for (Entry> entry : component.getComponentInstancesAttributes().entrySet()) { - attributesMap = new MapPropertiesDataDefinition(); - - attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()))); - - topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap); - } - } - } - - public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) { - ComponentMetadataData metadata = null; - switch (vertex.getType()) { - case SERVICE: - metadata = new ServiceMetadataData(vertex.getMetadataJson()); - break; - case RESOURCE: - metadata = new ResourceMetadataData(vertex.getMetadataJson()); - break; - case PRODUCT: - metadata = new ProductMetadataData(vertex.getMetadataJson()); - break; - default: - break; - } - if (metadata != null) { - metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId()); - metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE)); - metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID)); - metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE)); - } - return metadata; - } - - public static List convertToGroupDefinitions(Map groups) { - - List groupDefinitions = null; - if (MapUtils.isNotEmpty(groups)) { - groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList()); - } - return groupDefinitions; - } - - public static Map extractCapabilityProperteisFromInstances(List instances, boolean fromCsar) { - return instances - .stream() - .collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId, - ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar))); - } - - public static Map extractCapabilityPropertiesFromGroups(List groups, boolean fromCsar) { - if(CollectionUtils.isNotEmpty(groups)) - return groups - .stream() - .collect(Collectors.toMap(GroupDefinition::getUniqueId, - g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar))); - return Maps.newHashMap(); - } - - public static Map extractCapabilitiesFromGroups(final List groupDefinitions) { - Map calculatedCapabilities = Maps.newHashMap(); - for(GroupDefinition groupDefinition :groupDefinitions){ - calculatedCapabilities.put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition))); - } - return calculatedCapabilities; - } - - public static Map buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) { - return groupDefinition.getCapabilities().entrySet() - .stream() - .collect(Collectors.toMap(Map.Entry::getKey, e-> new ListCapabilityDataDefinition(e.getValue() - .stream() - .map(CapabilityDataDefinition::new) - .collect(Collectors.toList())))); - } - -} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/StorageException.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/StorageException.java index 40c39f3405..e75533f447 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/StorageException.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/StorageException.java @@ -1,6 +1,6 @@ package org.openecomp.sdc.be.model.operations; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; @@ -15,14 +15,16 @@ public class StorageException extends RuntimeException{ this.params = params; } - public StorageException(String message, Throwable cause, TitanOperationStatus titanOperationStatus, String... params){ + public StorageException(String message, Throwable cause, JanusGraphOperationStatus janusGraphOperationStatus, String... params){ super(message, cause); - storageOperationStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus); + storageOperationStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus); this.params = params; } - public StorageException(TitanOperationStatus titanOperationStatus, String... params) { - storageOperationStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus); + public StorageException(JanusGraphOperationStatus janusGraphOperationStatus, String... params) { + storageOperationStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus); this.params = params; } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IAdditionalInformationOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IAdditionalInformationOperation.java index 3fb58a0fa3..b1ce9de66e 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IAdditionalInformationOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IAdditionalInformationOperation.java @@ -20,9 +20,9 @@ package org.openecomp.sdc.be.model.operations.api; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.AdditionalInformationDefinition; @@ -32,19 +32,19 @@ import java.util.List; public interface IAdditionalInformationOperation { - public Either addAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String key, String value); + public Either addAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String key, String value); - public Either updateAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String origKey, String key, String value); + public Either updateAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String origKey, String key, String value); - public Either deleteAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String key); + public Either deleteAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String key); - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String resourceUniqueId); + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String resourceUniqueId); - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters); + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters); - public TitanOperationStatus findResourceAllAdditionalInformationRecursively(String uniqueId, List properties); + public JanusGraphOperationStatus findResourceAllAdditionalInformationRecursively(String uniqueId, List properties); - public TitanOperationStatus findServiceAllAdditionalInformationRecursively(String uniqueId, List properties); + public JanusGraphOperationStatus findServiceAllAdditionalInformationRecursively(String uniqueId, List properties); public Either createAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String key, String value, boolean inTransaction); @@ -54,20 +54,20 @@ public interface IAdditionalInformationOperation { public Either getNumberOfAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId, boolean inTransaction); - public Either getNumberOfParameters(NodeTypeEnum nodeType, String resourceId); + public Either getNumberOfParameters(NodeTypeEnum nodeType, String resourceId); - public Either getAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String id); + public Either getAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String id); public Either getAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String id, boolean inTransaction); - public Either getAllAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId, boolean ignoreVerification); + public Either getAllAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId, boolean ignoreVerification); public Either getAllAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId, boolean ignoreVerification, boolean inTransaction); public Either deleteAllAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId, boolean inTransaction); - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, TitanVertex matadatVertex); + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, JanusGraphVertex matadatVertex); - public TitanOperationStatus addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters, TitanVertex metadataVertex); + public JanusGraphOperationStatus addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters, JanusGraphVertex metadataVertex); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IArtifactOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IArtifactOperation.java index e1b04e9230..e3b7689d30 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IArtifactOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IArtifactOperation.java @@ -20,7 +20,7 @@ package org.openecomp.sdc.be.model.operations.api; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ArtifactDefinition; @@ -37,6 +37,6 @@ public interface IArtifactOperation { public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, boolean inTransaction); - public StorageOperationStatus addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, TitanVertex parentVertex); + public StorageOperationStatus addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, JanusGraphVertex parentVertex); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityOperation.java index da059fe3ad..3525e1362e 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityOperation.java @@ -21,13 +21,13 @@ package org.openecomp.sdc.be.model.operations.api; import fj.data.Either; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.PropertyDefinition; import java.util.Map; public interface ICapabilityOperation { - Either, TitanOperationStatus> getAllCapabilityTypePropertiesFromAllDerivedFrom(String firstParentType); + Either, JanusGraphOperationStatus> getAllCapabilityTypePropertiesFromAllDerivedFrom(String firstParentType); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityTypeOperation.java index 4316f733a7..780b9af70e 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityTypeOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/ICapabilityTypeOperation.java @@ -21,7 +21,7 @@ package org.openecomp.sdc.be.model.operations.api; import fj.data.Either; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; import java.util.Map; @@ -46,5 +46,5 @@ public interface ICapabilityTypeOperation { public Either getCapabilityType(String uniqueId); public Either getCapabilityType(String uniqueId, boolean inTransaction); - Either, TitanOperationStatus> getAllCapabilityTypes(); + Either, JanusGraphOperationStatus> getAllCapabilityTypes(); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInputsOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInputsOperation.java index 0c03ee3bf0..100916fe9e 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInputsOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInputsOperation.java @@ -21,13 +21,13 @@ package org.openecomp.sdc.be.model.operations.api; import org.apache.commons.lang3.tuple.ImmutablePair; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.ComponentInstanceInput; import org.openecomp.sdc.be.resources.data.InputValueData; public interface IInputsOperation { - ImmutablePair findInputValue(String resourceInstanceId, String propertyId); + ImmutablePair findInputValue(String resourceInstanceId, String propertyId); ComponentInstanceInput buildResourceInstanceInput(InputValueData propertyValueData, ComponentInstanceInput resourceInstanceInput); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AbstractOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AbstractOperation.java index 3e987ed101..c53f3e3d86 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AbstractOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AbstractOperation.java @@ -24,7 +24,7 @@ import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonElement; import com.google.gson.reflect.TypeToken; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import java.lang.reflect.Type; import java.util.List; @@ -37,9 +37,9 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -63,7 +63,7 @@ public abstract class AbstractOperation { private static final Logger log = Logger.getLogger(AbstractOperation.class.getName()); @Autowired - protected HealingTitanGenericDao titanGenericDao; + protected HealingJanusGraphGenericDao janusGraphGenericDao; public static final String EMPTY_VALUE = null; @@ -74,8 +74,8 @@ public abstract class AbstractOperation { protected DataTypeValidatorConverter dataTypeValidatorConverter = DataTypeValidatorConverter.getInstance(); - protected Either addDefinitionToNodeType(SomeDefenition someDefinition, NodeTypeEnum nodeType, String nodeUniqueId, final GraphEdgeLabels edgeType, - Supplier dataBuilder, Supplier defNameGenerator) { + protected Either addDefinitionToNodeType(SomeDefenition someDefinition, NodeTypeEnum nodeType, String nodeUniqueId, final GraphEdgeLabels edgeType, + Supplier dataBuilder, Supplier defNameGenerator) { String defName = defNameGenerator.get(); log.debug("Got {} {}", defName, someDefinition); @@ -84,29 +84,31 @@ public abstract class AbstractOperation { log.debug("Before adding {} to graph. data = {}", defName, someData); @SuppressWarnings("unchecked") - Either eitherSomeData = titanGenericDao.createNode(someData, (Class) someData.getClass()); + Either eitherSomeData = janusGraphGenericDao + .createNode(someData, (Class) someData.getClass()); log.debug("After adding {} to graph. status is = {}", defName, eitherSomeData); if (eitherSomeData.isRight()) { - TitanOperationStatus operationStatus = eitherSomeData.right().value(); + JanusGraphOperationStatus operationStatus = eitherSomeData.right().value(); log.error("Failed to add {} to graph. status is {}", defName, operationStatus); return Either.right(operationStatus); } UniqueIdData uniqueIdData = new UniqueIdData(nodeType, nodeUniqueId); log.debug("Before associating {} to {}.", uniqueIdData, defName); - Either eitherRelations = titanGenericDao.createRelation(uniqueIdData, eitherSomeData.left().value(), edgeType, null); + Either eitherRelations = janusGraphGenericDao + .createRelation(uniqueIdData, eitherSomeData.left().value(), edgeType, null); if (eitherRelations.isRight()) { - TitanOperationStatus operationStatus = eitherRelations.right().value(); + JanusGraphOperationStatus operationStatus = eitherRelations.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError("AddDefinitionToNodeType", "Failed to associate" + nodeType.getName() + " " + nodeUniqueId + "to " + defName + "in graph. status is " + operationStatus, ErrorSeverity.ERROR); return Either.right(operationStatus); } return Either.left(eitherSomeData.left().value()); } - protected TitanOperationStatus addDefinitionToNodeType(TitanVertex vertex, SomeDefenition someDefinition, NodeTypeEnum nodeType, String nodeUniqueId, final GraphEdgeLabels edgeType, - Supplier dataBuilder, Supplier defNameGenerator) { + protected JanusGraphOperationStatus addDefinitionToNodeType(JanusGraphVertex vertex, SomeDefenition someDefinition, NodeTypeEnum nodeType, String nodeUniqueId, final GraphEdgeLabels edgeType, + Supplier dataBuilder, Supplier defNameGenerator) { String defName = defNameGenerator.get(); log.debug("Got {} {}", defName, someDefinition); @@ -115,18 +117,20 @@ public abstract class AbstractOperation { log.debug("Before adding {} to graph. data = {}", defName, someData); @SuppressWarnings("unchecked") - Either eitherSomeData = titanGenericDao.createNode(someData); + Either eitherSomeData = janusGraphGenericDao.createNode(someData); log.debug("After adding {} to graph. status is = {}", defName, eitherSomeData); if (eitherSomeData.isRight()) { - TitanOperationStatus operationStatus = eitherSomeData.right().value(); + JanusGraphOperationStatus operationStatus = eitherSomeData.right().value(); log.error("Failed to add {} to graph. status is {}", defName, operationStatus); return operationStatus; } - TitanOperationStatus relations = titanGenericDao.createEdge(vertex, eitherSomeData.left().value(), edgeType, null); - if (!relations.equals(TitanOperationStatus.OK)) { + JanusGraphOperationStatus + relations = janusGraphGenericDao + .createEdge(vertex, eitherSomeData.left().value(), edgeType, null); + if (!relations.equals(JanusGraphOperationStatus.OK)) { BeEcompErrorManager.getInstance().logInternalFlowError("AddDefinitionToNodeType", "Failed to associate" + nodeType.getName() + " " + nodeUniqueId + "to " + defName + "in graph. status is " + relations, ErrorSeverity.ERROR); return relations; } @@ -134,25 +138,27 @@ public abstract class AbstractOperation { } interface NodeElementFetcher { - TitanOperationStatus findAllNodeElements(String nodeId, List listTofill); + JanusGraphOperationStatus findAllNodeElements(String nodeId, List listTofill); } - public TitanOperationStatus findAllResourceElementsDefinitionRecursively(String resourceId, List elements, NodeElementFetcher singleNodeFetcher) { + public JanusGraphOperationStatus findAllResourceElementsDefinitionRecursively(String resourceId, List elements, NodeElementFetcher singleNodeFetcher) { if (log.isTraceEnabled()) log.trace("Going to fetch elements under resource {}", resourceId); - TitanOperationStatus resourceAttributesStatus = singleNodeFetcher.findAllNodeElements(resourceId, elements); + JanusGraphOperationStatus + resourceAttributesStatus = singleNodeFetcher.findAllNodeElements(resourceId, elements); - if (resourceAttributesStatus != TitanOperationStatus.OK) { + if (resourceAttributesStatus != JanusGraphOperationStatus.OK) { return resourceAttributesStatus; } - Either, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, + Either, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); if (parentNodes.isRight()) { - TitanOperationStatus parentNodesStatus = parentNodes.right().value(); - if (parentNodesStatus != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value(); + if (parentNodesStatus != JanusGraphOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logInternalFlowError("findAllResourceElementsDefinitionRecursively", "Failed to find parent elements of resource " + resourceId + ". status is " + parentNodesStatus, ErrorSeverity.ERROR); return parentNodesStatus; } @@ -161,25 +167,25 @@ public abstract class AbstractOperation { if (parentNodes.isLeft()) { ImmutablePair parnetNodePair = parentNodes.left().value(); String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId(); - TitanOperationStatus addParentIntStatus = findAllResourceElementsDefinitionRecursively(parentUniqueId, elements, singleNodeFetcher); + JanusGraphOperationStatus addParentIntStatus = findAllResourceElementsDefinitionRecursively(parentUniqueId, elements, singleNodeFetcher); - if (addParentIntStatus != TitanOperationStatus.OK) { + if (addParentIntStatus != JanusGraphOperationStatus.OK) { BeEcompErrorManager.getInstance().logInternalFlowError("findAllResourceElementsDefinitionRecursively", "Failed to find all resource elements of resource " + parentUniqueId, ErrorSeverity.ERROR); return addParentIntStatus; } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } protected void handleTransactionCommitRollback(boolean inTransaction, Either result) { if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -212,7 +218,7 @@ public abstract class AbstractOperation { } String innerType = null; - Either checkInnerType = getInnerType(type, propertyDefinition::getSchema); + Either checkInnerType = getInnerType(type, propertyDefinition::getSchema); if (checkInnerType.isRight()) { return StorageOperationStatus.INVALID_TYPE; } @@ -300,19 +306,19 @@ public abstract class AbstractOperation { return value; } - protected Either getInnerType(ToscaPropertyType type, Supplier schemeGen) { + protected Either getInnerType(ToscaPropertyType type, Supplier schemeGen) { String innerType = null; if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) { SchemaDefinition def = schemeGen.get(); if (def == null) { log.debug("Schema doesn't exists for property of type {}", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } PropertyDataDefinition propDef = def.getProperty(); if (propDef == null) { log.debug("Property in Schema Definition inside property of type {} doesn't exist", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } innerType = propDef.getType(); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperation.java index ebec8b134b..f247bbb74d 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperation.java @@ -20,7 +20,7 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Vertex; @@ -29,10 +29,10 @@ import org.openecomp.sdc.be.dao.graph.GraphElementFactory; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition; import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -58,7 +58,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe private static final Logger log = Logger.getLogger(AdditionalInformationOperation.class.getName()); @javax.annotation.Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; private static final String GOING_TO_EXECUTE_COMMIT_ON_GRAPH = "Going to execute commit on graph."; private static final String GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH = "Going to execute rollback on graph."; @@ -71,18 +71,20 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe @Override - public Either addAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String key, String value) { + public Either addAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String key, String value) { - TitanOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); - if (verifyNodeTypeVsComponent != TitanOperationStatus.OK) { + JanusGraphOperationStatus + verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); + if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) { return Either.right(verifyNodeTypeVsComponent); } - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); return Either.right(status); } @@ -104,17 +106,18 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (parameters.containsKey(key)) { log.debug("The key {} already exists under component {}", key, componentId); - return Either.right(TitanOperationStatus.ALREADY_EXIST); + return Either.right(JanusGraphOperationStatus.ALREADY_EXIST); } idToKey.put(String.valueOf(lastCreatedCounter), key); parameters.put(key, value); parameterData.getAdditionalInfoParameterDataDefinition().setLastCreatedCounter(lastCreatedCounter); - Either updateNode = titanGenericDao.updateNode(parameterData, AdditionalInfoParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(parameterData, AdditionalInfoParameterData.class); if (updateNode.isRight()) { - TitanOperationStatus status = updateNode.right().value(); + JanusGraphOperationStatus status = updateNode.right().value(); BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("UpdateAdditionalInformationParameter", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status)); return Either.right(status); } @@ -126,18 +129,20 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either updateAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id, String key, String value) { + public Either updateAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id, String key, String value) { - TitanOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); - if (verifyNodeTypeVsComponent != TitanOperationStatus.OK) { + JanusGraphOperationStatus + verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); + if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) { return Either.right(verifyNodeTypeVsComponent); } - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); return Either.right(status); } @@ -146,7 +151,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe Map parameters = parameterData.getParameters(); Map idToKey = parameterData.getIdToKey(); if (idToKey == null || !idToKey.containsKey(id)) { - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } String origKey = idToKey.get(id); @@ -154,7 +159,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (!origKey.equals(key)) { if (parameters.containsKey(key)) { log.debug("The key {} already exists", key); - return Either.right(TitanOperationStatus.ALREADY_EXIST); + return Either.right(JanusGraphOperationStatus.ALREADY_EXIST); } String removed = parameters.remove(origKey); log.trace("The key-value {} = {} was removed from additionalInformation", origKey, removed); @@ -162,10 +167,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe parameters.put(key, value); idToKey.put(id, key); - Either updateNode = titanGenericDao.updateNode(parameterData, AdditionalInfoParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(parameterData, AdditionalInfoParameterData.class); if (updateNode.isRight()) { - TitanOperationStatus status = updateNode.right().value(); + JanusGraphOperationStatus status = updateNode.right().value(); BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("UpdateAdditionalInformationParameter", "additional information of resource " + componentId, String.valueOf(status)); return Either.right(status); } @@ -177,18 +183,20 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either deleteAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id) { + public Either deleteAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id) { - TitanOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); - if (verifyNodeTypeVsComponent != TitanOperationStatus.OK) { + JanusGraphOperationStatus + verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); + if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) { return Either.right(verifyNodeTypeVsComponent); } - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); return Either.right(status); } @@ -198,7 +206,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe Map idToKey = parameterData.getIdToKey(); if (idToKey == null || !idToKey.containsKey(id)) { - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } String key = idToKey.get(id); @@ -206,10 +214,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe String removedValue = parameters.remove(key); log.trace("The key-value {} = {} was removed from additionalInformation", removedKey, removedValue); - Either updateNode = titanGenericDao.updateNode(parameterData, AdditionalInfoParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(parameterData, AdditionalInfoParameterData.class); if (updateNode.isRight()) { - TitanOperationStatus status = updateNode.right().value(); + JanusGraphOperationStatus status = updateNode.right().value(); BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("DeleteAdditionalInformationParameter", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status)); return Either.right(status); } @@ -248,7 +257,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId) { + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId) { UniqueIdData from = new UniqueIdData(nodeType, componentId); @@ -258,18 +267,20 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe AdditionalInfoParameterData additionalInfoParameterData = new AdditionalInfoParameterData(additionalInfoParameterDataDefinition, new HashMap<>(), new HashMap<>()); - Either createNode = titanGenericDao.createNode(additionalInfoParameterData, AdditionalInfoParameterData.class); + Either createNode = janusGraphGenericDao + .createNode(additionalInfoParameterData, AdditionalInfoParameterData.class); if (createNode.isRight()) { - TitanOperationStatus status = createNode.right().value(); + JanusGraphOperationStatus status = createNode.right().value(); BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("AddAdditionalInformationNode", uniqueId, String.valueOf(status)); return Either.right(status); } AdditionalInfoParameterData to = createNode.left().value(); - Either createRelation = titanGenericDao.createRelation(from, to, GraphEdgeLabels.ADDITIONAL_INFORMATION, null); + Either createRelation = janusGraphGenericDao + .createRelation(from, to, GraphEdgeLabels.ADDITIONAL_INFORMATION, null); if (createRelation.isRight()) { - TitanOperationStatus status = createRelation.right().value(); + JanusGraphOperationStatus status = createRelation.right().value(); return Either.right(status); } @@ -277,7 +288,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, TitanVertex metadataVertex) { + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, JanusGraphVertex metadataVertex) { String uniqueId = UniqueIdBuilder.buildAdditionalInformationUniqueId(componentId); AdditionalInfoParameterDataDefinition additionalInfoParameterDataDefinition = new AdditionalInfoParameterDataDefinition(); @@ -285,26 +296,27 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe AdditionalInfoParameterData additionalInfoParameterData = new AdditionalInfoParameterData(additionalInfoParameterDataDefinition, new HashMap<>(), new HashMap<>()); - Either createNode = titanGenericDao.createNode(additionalInfoParameterData); + Either createNode = janusGraphGenericDao.createNode(additionalInfoParameterData); if (createNode.isRight()) { - TitanOperationStatus status = createNode.right().value(); + JanusGraphOperationStatus status = createNode.right().value(); BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("AddAdditionalInformationNode", uniqueId, String.valueOf(status)); return Either.right(status); } - TitanVertex additionalInfoVertex = createNode.left().value(); + JanusGraphVertex additionalInfoVertex = createNode.left().value(); - TitanOperationStatus createRelation = titanGenericDao.createEdge(metadataVertex, additionalInfoVertex, GraphEdgeLabels.ADDITIONAL_INFORMATION, null); + JanusGraphOperationStatus createRelation = janusGraphGenericDao + .createEdge(metadataVertex, additionalInfoVertex, GraphEdgeLabels.ADDITIONAL_INFORMATION, null); - if (!createRelation.equals(TitanOperationStatus.OK)) { + if (!createRelation.equals(JanusGraphOperationStatus.OK)) { return Either.right(createRelation); } return Either.left(additionalInfoVertex); } - public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters) { + public Either addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters) { - Either status = this.addAdditionalInformationNode(nodeType, componentId); + Either status = this.addAdditionalInformationNode(nodeType, componentId); if (status.isRight()) { return Either.right(status.right().value()); @@ -314,7 +326,8 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe populateParameterNodeWithParameters(parameterData, parameters); - Either updateNode = titanGenericDao.updateNode(parameterData, AdditionalInfoParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(parameterData, AdditionalInfoParameterData.class); if (updateNode.isRight()) { return Either.right(updateNode.right().value()); @@ -325,21 +338,21 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe return Either.left(informationDefinition); } - public TitanOperationStatus addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters, TitanVertex metadataVertex) { + public JanusGraphOperationStatus addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId, AdditionalInformationDefinition parameters, JanusGraphVertex metadataVertex) { - Either status = this.addAdditionalInformationNode(nodeType, componentId, metadataVertex); + Either status = this.addAdditionalInformationNode(nodeType, componentId, metadataVertex); if (status.isRight()) { return status.right().value(); } - TitanVertex additionalInfoVertex = status.left().value(); + JanusGraphVertex additionalInfoVertex = status.left().value(); - Map newProp = titanGenericDao.getProperties(additionalInfoVertex); + Map newProp = janusGraphGenericDao.getProperties(additionalInfoVertex); AdditionalInfoParameterData parameterData = GraphElementFactory.createElement(NodeTypeEnum.AdditionalInfoParameters.getName(), GraphElementTypeEnum.Node, newProp, AdditionalInfoParameterData.class); populateParameterNodeWithParameters(parameterData, parameters); - return titanGenericDao.updateVertex(parameterData, additionalInfoVertex); + return janusGraphGenericDao.updateVertex(parameterData, additionalInfoVertex); } private void populateParameterNodeWithParameters(AdditionalInfoParameterData parameterData, AdditionalInformationDefinition aiDefinition) { @@ -373,21 +386,22 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public TitanOperationStatus findResourceAllAdditionalInformationRecursively(String uniqueId, List properties) { + public JanusGraphOperationStatus findResourceAllAdditionalInformationRecursively(String uniqueId, List properties) { log.trace("Going to fetch additional information under resource {}", uniqueId); - TitanOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Resource, uniqueId, properties); + JanusGraphOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Resource, uniqueId, properties); - if (!resourceCapabilitiesStatus.equals(TitanOperationStatus.OK)) { + if (!resourceCapabilitiesStatus.equals(JanusGraphOperationStatus.OK)) { return resourceCapabilitiesStatus; } - Either, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, + Either, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); if (parentNodes.isRight()) { - TitanOperationStatus parentNodesStatus = parentNodes.right().value(); - if (!parentNodesStatus.equals(TitanOperationStatus.NOT_FOUND)) { + JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value(); + if (!parentNodesStatus.equals(JanusGraphOperationStatus.NOT_FOUND)) { log.error("Failed to find parent additional information of resource {}. status is {}", uniqueId, parentNodesStatus); return parentNodesStatus; } @@ -396,33 +410,34 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (parentNodes.isLeft()) { ImmutablePair parnetNodePair = parentNodes.left().value(); String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId(); - TitanOperationStatus addParentIntStatus = findResourceAllAdditionalInformationRecursively(parentUniqueId, properties); + JanusGraphOperationStatus addParentIntStatus = findResourceAllAdditionalInformationRecursively(parentUniqueId, properties); - if (addParentIntStatus != TitanOperationStatus.OK) { + if (addParentIntStatus != JanusGraphOperationStatus.OK) { log.error("Failed to find all resource additional information of resource {}", parentUniqueId); return addParentIntStatus; } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } @Override - public TitanOperationStatus findServiceAllAdditionalInformationRecursively(String uniqueId, List properties) { + public JanusGraphOperationStatus findServiceAllAdditionalInformationRecursively(String uniqueId, List properties) { log.trace("Going to fetch additional information under service {}", uniqueId); - TitanOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Service, uniqueId, properties); + JanusGraphOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Service, uniqueId, properties); - if (!resourceCapabilitiesStatus.equals(TitanOperationStatus.OK)) { + if (!resourceCapabilitiesStatus.equals(JanusGraphOperationStatus.OK)) { return resourceCapabilitiesStatus; } - Either, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Service, + Either, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Service, ServiceMetadataData.class); if (parentNodes.isRight()) { - TitanOperationStatus parentNodesStatus = parentNodes.right().value(); - if (!parentNodesStatus.equals(TitanOperationStatus.NOT_FOUND)) { + JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value(); + if (!parentNodesStatus.equals(JanusGraphOperationStatus.NOT_FOUND)) { log.error("Failed to find parent additional information of resource {}. status is {}", uniqueId, parentNodesStatus); return parentNodesStatus; } @@ -431,26 +446,27 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (parentNodes.isLeft()) { ImmutablePair parnetNodePair = parentNodes.left().value(); String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId(); - TitanOperationStatus addParentIntStatus = findServiceAllAdditionalInformationRecursively(parentUniqueId, properties); + JanusGraphOperationStatus addParentIntStatus = findServiceAllAdditionalInformationRecursively(parentUniqueId, properties); - if (addParentIntStatus != TitanOperationStatus.OK) { + if (addParentIntStatus != JanusGraphOperationStatus.OK) { log.error("Failed to find all resource additional information of resource {}", parentUniqueId); return addParentIntStatus; } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - private TitanOperationStatus findAdditionalInformationOfNode(NodeTypeEnum nodeType, String uniqueId, List properties) { + private JanusGraphOperationStatus findAdditionalInformationOfNode(NodeTypeEnum nodeType, String uniqueId, List properties) { - Either, TitanOperationStatus> childNode = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> childNode = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (childNode.isRight()) { - TitanOperationStatus status = childNode.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childNode.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } return status; } @@ -464,7 +480,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe properties.add(additionalInfoDef); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } @@ -483,13 +499,13 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.addAdditionalInformationParameter(nodeType, resourceId, key, value); + Either either = this.addAdditionalInformationParameter(nodeType, resourceId, key, value); if (either.isRight()) { - TitanOperationStatus status = either.right().value(); + JanusGraphOperationStatus status = either.right().value(); log.debug("Failed to add additional information property {} to component {}. Status is {}", key, resourceId, status); BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("CreateAdditionalInformationParameter", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + resourceId, String.valueOf(status)); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } else { AdditionalInformationDefinition additionalInformationDefinition = either.left().value(); result = Either.left(additionalInformationDefinition); @@ -509,11 +525,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.updateAdditionalInformationParameter(nodeType, resourceId, id, key, value); + Either either = this.updateAdditionalInformationParameter(nodeType, resourceId, id, key, value); if (either.isRight()) { log.info("Failed to update additional information property {} to component {}", key, resourceId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value())); } else { AdditionalInformationDefinition additionalInformationDefinition = either.left().value(); result = Either.left(additionalInformationDefinition); @@ -534,11 +550,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.deleteAdditionalInformationParameter(nodeType, resourceId, id); + Either either = this.deleteAdditionalInformationParameter(nodeType, resourceId, id); if (either.isRight()) { log.error("Failed to delete additional information id {} to component {}", id, resourceId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value())); } else { AdditionalInformationDefinition additionalInformationDefinition = either.left().value(); result = Either.left(additionalInformationDefinition); @@ -559,11 +575,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.getNumberOfParameters(nodeType, resourceId); + Either either = this.getNumberOfParameters(nodeType, resourceId); if (either.isRight()) { log.error("Failed to get the number of additional information properties in component {}", resourceId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value())); } else { Integer counter = either.left().value(); result = Either.left(counter); @@ -574,10 +590,10 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -585,13 +601,14 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either getNumberOfParameters(NodeTypeEnum nodeType, String resourceId) { + public Either getNumberOfParameters(NodeTypeEnum nodeType, String resourceId) { - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); return Either.right(status); } @@ -609,18 +626,20 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either getAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id) { + public Either getAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId, String id) { - TitanOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); - if (verifyNodeTypeVsComponent != TitanOperationStatus.OK) { + JanusGraphOperationStatus + verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); + if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) { return Either.right(verifyNodeTypeVsComponent); } - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); return Either.right(status); } @@ -630,7 +649,7 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe Map idToKey = parameterData.getIdToKey(); if (idToKey == null || !idToKey.containsKey(id)) { - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } String key = idToKey.get(id); @@ -638,11 +657,12 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe log.trace("The key-value {} = {} was retrieved for id {}", key, value, id); - Either updateNode = titanGenericDao.updateNode(parameterData, AdditionalInfoParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(parameterData, AdditionalInfoParameterData.class); if (updateNode.isRight()) { - TitanOperationStatus status = updateNode.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = updateNode.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("GetAdditionnalInformationParameter", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status)); } return Either.right(status); @@ -655,21 +675,23 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } @Override - public Either getAllAdditionalInformationParameters(NodeTypeEnum nodeType, String componentId, boolean ignoreVerification) { + public Either getAllAdditionalInformationParameters(NodeTypeEnum nodeType, String componentId, boolean ignoreVerification) { if (!ignoreVerification) { - TitanOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); - if (verifyNodeTypeVsComponent != TitanOperationStatus.OK) { + JanusGraphOperationStatus + verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId); + if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) { return Either.right(verifyNodeTypeVsComponent); } } - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = getResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("GetAdditionnalInformationParameters", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status)); } return Either.right(status); @@ -693,11 +715,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.getAllAdditionalInformationParameters(nodeType, resourceId, ignoreVerification); + Either either = this.getAllAdditionalInformationParameters(nodeType, resourceId, ignoreVerification); if (either.isRight()) { - TitanOperationStatus status = either.right().value(); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + JanusGraphOperationStatus status = either.right().value(); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } else { AdditionalInformationDefinition additionalInformationDefinition = either.left().value(); result = Either.left(additionalInformationDefinition); @@ -716,10 +738,10 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -732,11 +754,11 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either either = this.getAdditionalInformationParameter(nodeType, resourceId, id); + Either either = this.getAdditionalInformationParameter(nodeType, resourceId, id); if (either.isRight()) { log.error("Failed to fetch additional information property with id {} of component {}", id, resourceId); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value())); } else { AdditionalInfoParameterInfo additionalInformationDefinition = either.left().value(); result = Either.left(additionalInformationDefinition); @@ -756,16 +778,17 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe try { - Either, TitanOperationStatus> getResult = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION, + Either, JanusGraphOperationStatus> getResult = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION, NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class); if (getResult.isRight()) { - TitanOperationStatus status = getResult.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = getResult.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(StorageOperationStatus.OK); } else { BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("DeleteAdditionalInformationNode", ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + resourceId, String.valueOf(status)); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } return result; } @@ -773,11 +796,12 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe ImmutablePair value = getResult.left().value(); AdditionalInfoParameterData parameterData = value.getLeft(); - Either deleteNodeRes = titanGenericDao.deleteNode(parameterData, AdditionalInfoParameterData.class); + Either deleteNodeRes = janusGraphGenericDao + .deleteNode(parameterData, AdditionalInfoParameterData.class); if (deleteNodeRes.isRight()) { - TitanOperationStatus status = getResult.right().value(); + JanusGraphOperationStatus status = getResult.right().value(); BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("DeleteAdditionalInformationNode", (String) parameterData.getUniqueId(), String.valueOf(status)); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } @@ -792,12 +816,13 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe } } - private TitanOperationStatus verifyNodeTypeVsComponent(NodeTypeEnum nodeType, String componentId) { - Either vertexByProperty = titanGenericDao.getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId); + private JanusGraphOperationStatus verifyNodeTypeVsComponent(NodeTypeEnum nodeType, String componentId) { + Either vertexByProperty = janusGraphGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId); if (vertexByProperty.isRight()) { - TitanOperationStatus status = vertexByProperty.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = vertexByProperty.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return status; } else { @@ -806,14 +831,14 @@ public class AdditionalInformationOperation implements IAdditionalInformationOpe if (label != null) { if (!label.equals(nodeType.getName())) { log.debug("The node type {} is not appropriate to component {}", nodeType, componentId); - return TitanOperationStatus.INVALID_ID; + return JanusGraphOperationStatus.INVALID_ID; } } else { log.debug("The node type {} with id {} does not have a label property.", nodeType, componentId); - return TitanOperationStatus.INVALID_ID; + return JanusGraphOperationStatus.INVALID_ID; } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperation.java index 9beb2053a3..4e65fa5d2b 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperation.java @@ -20,8 +20,8 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Direction; @@ -33,11 +33,11 @@ import org.openecomp.sdc.be.dao.graph.GraphElementFactory; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ArtifactDefinition; @@ -61,7 +61,7 @@ public class ArtifactOperation implements IArtifactOperation { private static final String THE_RETURNED_ARTIFACT_DEFINTION_IS = "The returned ArtifactDefintion is {}"; @javax.annotation.Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; @javax.annotation.Resource private HeatParametersOperation heatParametersOperation; @@ -77,12 +77,12 @@ public class ArtifactOperation implements IArtifactOperation { super(); } - public TitanGenericDao getTitanGenericDao() { - return titanGenericDao; + public JanusGraphGenericDao getJanusGraphGenericDao() { + return janusGraphGenericDao; } - public void setTitanGenericDao(TitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } public HeatParametersOperation getHeatParametersOperation() { @@ -100,13 +100,13 @@ public class ArtifactOperation implements IArtifactOperation { if (status.isRight()) { if (!inTransaction) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } log.debug("Failed to add artifact {} to {} {}", artifactInfo.getArtifactName(), type , parentId); return Either.right(status.right().value()); } else { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } ArtifactData artifactData = status.left().value(); @@ -119,7 +119,7 @@ public class ArtifactOperation implements IArtifactOperation { } @Override - public StorageOperationStatus addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, TitanVertex parentVertex) { + public StorageOperationStatus addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, JanusGraphVertex parentVertex) { StorageOperationStatus status = addArtifactToGraph(artifactInfo, parentId, type, failIfExist, parentVertex); @@ -129,7 +129,7 @@ public class ArtifactOperation implements IArtifactOperation { return status; } - private StorageOperationStatus addArtifactToGraph(ArtifactDefinition artifactInfo, String id, NodeTypeEnum type, boolean failIfexist, TitanVertex parentVertex) { + private StorageOperationStatus addArtifactToGraph(ArtifactDefinition artifactInfo, String id, NodeTypeEnum type, boolean failIfexist, JanusGraphVertex parentVertex) { if (artifactInfo.getUniqueId() == null || artifactInfo.getUniqueId().isEmpty()) { String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(id, artifactInfo.getArtifactLabel()); @@ -142,20 +142,21 @@ public class ArtifactOperation implements IArtifactOperation { ArtifactData artifactData = new ArtifactData(artifactInfo); - Either existArtifact = titanGenericDao.getVertexByProperty(artifactData.getUniqueIdKey(), artifactData.getUniqueId()); + Either existArtifact = janusGraphGenericDao + .getVertexByProperty(artifactData.getUniqueIdKey(), artifactData.getUniqueId()); if (existArtifact.isRight()) { - if (existArtifact.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + if (existArtifact.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) { // create new node log.debug("Before adding artifact to graph {}", artifactData); if (artifactData.getArtifactDataDefinition().getArtifactUUID() == null || artifactData.getArtifactDataDefinition().getArtifactUUID().isEmpty()) updateUUID(artifactData.getArtifactDataDefinition(), null, artifactData.getArtifactDataDefinition().getArtifactVersion()); - Either createNodeResult = titanGenericDao.createNode(artifactData); + Either createNodeResult = janusGraphGenericDao.createNode(artifactData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.debug("Failed to add artifact {} to graph. status is {}", artifactData.getArtifactDataDefinition().getArtifactName(), operationStatus); BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("Add artifact", artifactData.getArtifactDataDefinition().getArtifactName(), String.valueOf(operationStatus)); - return DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus); } // add heat parameters @@ -169,11 +170,11 @@ public class ArtifactOperation implements IArtifactOperation { } else { log.debug("Failed to check existance of artifact in graph for id {}", artifactData.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(existArtifact.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(existArtifact.right().value()); } } else if (failIfexist) { log.debug("Artifact {} already exist", artifactData.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ALREADY_EXIST); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ALREADY_EXIST); } // save logical artifact ref name on edge as property @@ -181,10 +182,11 @@ public class ArtifactOperation implements IArtifactOperation { properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), artifactInfo.getArtifactLabel()); if (artifactInfo.getArtifactGroupType() != null) properties.put(GraphEdgePropertiesDictionary.GROUP_TYPE.getProperty(), artifactInfo.getArtifactGroupType().getType()); - TitanOperationStatus relation = titanGenericDao.createEdge(parentVertex, artifactData, GraphEdgeLabels.ARTIFACT_REF, properties); - if (!relation.equals(TitanOperationStatus.OK)) { + JanusGraphOperationStatus relation = janusGraphGenericDao + .createEdge(parentVertex, artifactData, GraphEdgeLabels.ARTIFACT_REF, properties); + if (!relation.equals(JanusGraphOperationStatus.OK)) { log.debug("Failed to create relation in graph for id {} to new artifact", id); - return DaoStatusConverter.convertTitanStatusToStorageStatus(relation); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(relation); } return StorageOperationStatus.OK; @@ -203,21 +205,23 @@ public class ArtifactOperation implements IArtifactOperation { ArtifactData artifactData = new ArtifactData(artifactInfo); - Either existArtifact = titanGenericDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + Either existArtifact = janusGraphGenericDao + .getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); if (existArtifact.isRight()) { - if (existArtifact.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + if (existArtifact.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) { // create new node log.debug("Before adding artifact to graph {}" , artifactData); if (artifactData.getArtifactDataDefinition().getArtifactUUID() == null || artifactData.getArtifactDataDefinition().getArtifactUUID().isEmpty()) updateUUID(artifactData.getArtifactDataDefinition(), null, artifactData.getArtifactDataDefinition().getArtifactVersion()); - Either createNodeResult = titanGenericDao.createNode(artifactData, ArtifactData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(artifactData, ArtifactData.class); log.debug("After adding artifact to graph {}", artifactData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.debug("Failed to add artifact {} to graph. status is {}", artifactData.getArtifactDataDefinition().getArtifactName(), operationStatus); BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("Add artifact", artifactData.getArtifactDataDefinition().getArtifactName(), String.valueOf(operationStatus)); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); } artifactData = createNodeResult.left().value(); @@ -232,11 +236,12 @@ public class ArtifactOperation implements IArtifactOperation { } else { log.debug("Failed to check existance of artifact in graph for id {}", artifactData.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(existArtifact.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(existArtifact.right().value())); } } else if (failIfexist) { log.debug("Artifact {} already exist", artifactData.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ALREADY_EXIST)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + JanusGraphOperationStatus.ALREADY_EXIST)); } else { artifactData = existArtifact.left().value(); } @@ -248,10 +253,11 @@ public class ArtifactOperation implements IArtifactOperation { properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), artifactInfo.getArtifactLabel()); if (artifactInfo.getArtifactGroupType() != null) properties.put(GraphEdgePropertiesDictionary.GROUP_TYPE.getProperty(), artifactInfo.getArtifactGroupType().getType()); - Either relation = titanGenericDao.createRelation(parent, artifactData, GraphEdgeLabels.ARTIFACT_REF, properties); + Either relation = janusGraphGenericDao + .createRelation(parent, artifactData, GraphEdgeLabels.ARTIFACT_REF, properties); if (relation.isRight()) { log.debug("Failed to create relation in graph fro id {} to new artifact", id); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(relation.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(relation.right().value())); } return Either.left(artifactData); @@ -291,14 +297,14 @@ public class ArtifactOperation implements IArtifactOperation { if (status.isRight()) { if (!inTransaction) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } log.debug("Failed to update artifact {} of {} {}. status is {}", artifactId, type.getName(), id, status.right().value()); BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactId, String.valueOf(status.right().value())); return Either.right(status.right().value()); } else { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } ArtifactData artifactData = status.left().value(); @@ -314,7 +320,7 @@ public class ArtifactOperation implements IArtifactOperation { if (status.isRight()) { if (!inTransaction) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } log.debug("Failed to delete artifact {} of resource {}", artifactId, id); @@ -322,7 +328,7 @@ public class ArtifactOperation implements IArtifactOperation { return Either.right(status.right().value()); } else { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } ArtifactData artifactData = status.left().value(); @@ -335,21 +341,21 @@ public class ArtifactOperation implements IArtifactOperation { @SuppressWarnings("null") private Either updateArtifactOnGraph(ArtifactDefinition artifactInfo, String artifactId, NodeTypeEnum type, String id) { - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graph.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graph.right().value())); } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); @SuppressWarnings("unchecked") - Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId).vertices(); - Iterator iterator = verticesArtifact.iterator(); + Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId).vertices(); + Iterator iterator = verticesArtifact.iterator(); if (!iterator.hasNext()) { log.debug("No artifact node for id = {}", artifactId); return Either.right(StorageOperationStatus.NOT_FOUND); } - TitanVertex artifactV = iterator.next(); + JanusGraphVertex artifactV = iterator.next(); Iterator iterEdge = artifactV.edges(Direction.IN, GraphEdgeLabels.ARTIFACT_REF.getProperty()); @@ -385,8 +391,10 @@ public class ArtifactOperation implements IArtifactOperation { String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(id, artifactInfo.getArtifactLabel()); artifactInfo.setUniqueId(uniqueId); // update UUID and artifact version - String oldChecksum = artifactV.valueOrNull(titanGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_CHECKSUM.getProperty())); - String oldVersion = artifactV.valueOrNull(titanGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_VERSION.getProperty())); + String oldChecksum = artifactV.valueOrNull( + janusGraphGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_CHECKSUM.getProperty())); + String oldVersion = artifactV.valueOrNull( + janusGraphGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_VERSION.getProperty())); updateUUID(artifactInfo, oldChecksum, oldVersion); log.debug("try to create new artifact ref node for id {}", uniqueId); Either addedArtifactRes = addArtifactToGraph(artifactInfo, id, type, true); @@ -435,10 +443,11 @@ public class ArtifactOperation implements IArtifactOperation { Vertex vertexIn = edgeToHeat.inVertex(); String generatedFromArtifactId = vertexIn.value(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef)); UniqueIdData generatedFromArtifactNode = new UniqueIdData(NodeTypeEnum.ArtifactRef, generatedFromArtifactId); - Either createRelationToGeneratedFromArtifactRes = titanGenericDao.createRelation(addedArtifact, generatedFromArtifactNode, GraphEdgeLabels.GENERATED_FROM, null); + Either createRelationToGeneratedFromArtifactRes = janusGraphGenericDao + .createRelation(addedArtifact, generatedFromArtifactNode, GraphEdgeLabels.GENERATED_FROM, null); if (createRelationToGeneratedFromArtifactRes.isRight()) { log.error("Failed to create relation from heat_env {} to heat {}", addedArtifact.getUniqueId(), generatedFromArtifactNode); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createRelationToGeneratedFromArtifactRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createRelationToGeneratedFromArtifactRes.right().value())); } } } @@ -446,14 +455,17 @@ public class ArtifactOperation implements IArtifactOperation { } else { if (edgeCount == 1) { - String oldChecksum = artifactV.valueOrNull(titanGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_CHECKSUM.getProperty())); - String oldVersion = artifactV.valueOrNull(titanGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_VERSION.getProperty())); + String oldChecksum = artifactV.valueOrNull( + janusGraphGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_CHECKSUM.getProperty())); + String oldVersion = artifactV.valueOrNull( + janusGraphGenericDao.getGraph().left().value().getPropertyKey(GraphPropertiesDictionary.ARTIFACT_VERSION.getProperty())); updateUUID(artifactInfo, oldChecksum, oldVersion); // update exist - Either updatedArtifact = titanGenericDao.updateNode(artifactData, ArtifactData.class); + Either updatedArtifact = janusGraphGenericDao + .updateNode(artifactData, ArtifactData.class); if (updatedArtifact.isRight()) { log.debug("failed to update artifact node for id {}", artifactData.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updatedArtifact.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updatedArtifact.right().value())); } if (artifactInfo.getArtifactType().equals(ArtifactTypeEnum.HEAT_ENV.getType())) { @@ -511,7 +523,7 @@ public class ArtifactOperation implements IArtifactOperation { return false; } - private Either setRelevantHeatParamId(TitanVertex artifactV, ArtifactDefinition artifactInfo) { + private Either setRelevantHeatParamId(JanusGraphVertex artifactV, ArtifactDefinition artifactInfo) { Map heatParametersHM = new HashMap<>(); @@ -524,7 +536,8 @@ public class ArtifactOperation implements IArtifactOperation { Vertex heatVertex = heat.inVertex(); String heatUniqueId = (String) heatVertex.value(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef)); - Either>, TitanOperationStatus> getHeatParametersRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatUniqueId, GraphEdgeLabels.HEAT_PARAMETER, + Either>, JanusGraphOperationStatus> getHeatParametersRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatUniqueId, GraphEdgeLabels.HEAT_PARAMETER, NodeTypeEnum.HeatParameter, HeatParameterData.class); if (getHeatParametersRes.isRight()) { log.debug("No heat parameters for heat artifact {}", heatUniqueId); @@ -550,17 +563,18 @@ public class ArtifactOperation implements IArtifactOperation { } private Either removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) { - Either graph = titanGenericDao.getGraph() + Either graph = janusGraphGenericDao.getGraph() .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (graph.isRight()) { return Either.right(graph.right().value()); } - TitanGraph tGraph = graph.left().value(); - Either artifactData = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId, ArtifactData.class) + JanusGraph tGraph = graph.left().value(); + Either artifactData = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId, ArtifactData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (artifactData.isRight()) { log.debug("Failed to retrieve artifact for id = {}", artifactId); return Either.right(artifactData.right().value()); @@ -572,8 +586,8 @@ public class ArtifactOperation implements IArtifactOperation { } @SuppressWarnings("unchecked") - Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId).vertices(); - Iterator iterator = verticesArtifact.iterator(); + Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ArtifactRef), artifactId).vertices(); + Iterator iterator = verticesArtifact.iterator(); if (!iterator.hasNext()) { log.debug("No artifact node for id = {}", artifactId); return Either.right(StorageOperationStatus.NOT_FOUND); @@ -649,20 +663,20 @@ public class ArtifactOperation implements IArtifactOperation { public Either, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, boolean inTransaction) { Either, StorageOperationStatus> result = null; try { - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { log.debug("Failed to work with graph {}", graph.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graph.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graph.right().value())); } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); @SuppressWarnings("unchecked") - Iterable vertices = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(parentType), parentId).vertices(); + Iterable vertices = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(parentType), parentId).vertices(); if (vertices == null) { log.debug("No nodes for type {} for id = {}", parentType, parentId); result = Either.right(StorageOperationStatus.NOT_FOUND); return result; } - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); Map artifactMap = new HashMap<>(); while (iterator.hasNext()) { @@ -676,15 +690,16 @@ public class ArtifactOperation implements IArtifactOperation { Vertex artifactV = edge.inVertex(); - Map properties = this.titanGenericDao.getProperties(artifactV); + Map properties = this.janusGraphGenericDao.getProperties(artifactV); ArtifactData artifact = GraphElementFactory.createElement(NodeTypeEnum.ArtifactRef.getName(), GraphElementTypeEnum.Node, properties, ArtifactData.class); if (artifact != null) { ArtifactDefinition artifactDefinition = new ArtifactDefinition(artifact.getArtifactDataDefinition()); Iterator edgesGeneratedFrom = artifactV.edges(Direction.OUT, GraphEdgeLabels.GENERATED_FROM.getProperty()); if (edgesGeneratedFrom != null && edgesGeneratedFrom.hasNext()) { - TitanVertex inVertex = (TitanVertex) edgesGeneratedFrom.next().inVertex(); - String artifactIdGeneratedFrom = (String) titanGenericDao.getProperty(inVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + JanusGraphVertex inVertex = (JanusGraphVertex) edgesGeneratedFrom.next().inVertex(); + String artifactIdGeneratedFrom = (String) janusGraphGenericDao + .getProperty(inVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); artifactDefinition.setGeneratedFromId(artifactIdGeneratedFrom); } List heatParams = new ArrayList<>(); @@ -707,9 +722,9 @@ public class ArtifactOperation implements IArtifactOperation { } finally { if (!inTransaction) { if (result == null || result.isRight()) { - this.titanGenericDao.rollback(); + this.janusGraphGenericDao.rollback(); } else { - this.titanGenericDao.commit(); + this.janusGraphGenericDao.commit(); } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CacheMangerOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CacheMangerOperation.java index 3a0eef1a46..abd3c91eea 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CacheMangerOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CacheMangerOperation.java @@ -23,7 +23,7 @@ package org.openecomp.sdc.be.model.operations.impl; import com.google.common.util.concurrent.ThreadFactoryBuilder; import org.openecomp.sdc.be.config.Configuration; import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.cache.ComponentCache; import org.openecomp.sdc.be.model.cache.DaoInfo; @@ -31,7 +31,7 @@ import org.openecomp.sdc.be.model.cache.jobs.*; import org.openecomp.sdc.be.model.cache.workers.CacheWorker; import org.openecomp.sdc.be.model.cache.workers.IWorker; import org.openecomp.sdc.be.model.cache.workers.SyncWorker; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation; import org.openecomp.sdc.common.log.wrappers.Logger; import org.springframework.beans.factory.annotation.Autowired; @@ -50,7 +50,7 @@ public class CacheMangerOperation implements ICacheMangerOperation { @Autowired private ToscaOperationFacade toscaOperationFacade; @Autowired - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; @Autowired private ComponentCache componentCache; @@ -183,8 +183,8 @@ public class CacheMangerOperation implements ICacheMangerOperation { } } - public TitanGenericDao getTitanGenericDao() { - return titanGenericDao; + public JanusGraphGenericDao getJanusGraphGenericDao() { + return janusGraphGenericDao; } public ComponentCache getComponentCache() { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityOperation.java index 382a2e00f7..ed635d1a0a 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityOperation.java @@ -36,11 +36,11 @@ import java.util.stream.Collectors; import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.CapabilityDefinition; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; @@ -71,11 +71,11 @@ public class CapabilityOperation extends AbstractOperation { @VisibleForTesting - public void setTitanGenericDao(HealingTitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(HealingJanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } - public Either addCapabilityToGraph(String resourceId, CapabilityTypeData capTypeData, CapabilityDefinition capabilityDefinition) { + public Either addCapabilityToGraph(String resourceId, CapabilityTypeData capTypeData, CapabilityDefinition capabilityDefinition) { log.debug("#addCapabilityToGraph - capabilityDefinition={}", capabilityDefinition); @@ -83,11 +83,12 @@ public class CapabilityOperation extends AbstractOperation { CapabilityData capabilityData = buildCapabilityData(capabilityDefinition, capUniqueId); log.debug("addCapabilityToGraph - Before adding capability to graph. capabilityTypeData = {}", capabilityData); - Either createCapResult = titanGenericDao.createNode(capabilityData, CapabilityData.class); + Either createCapResult = janusGraphGenericDao + .createNode(capabilityData, CapabilityData.class); log.debug("addCapabilityToGraph - After adding capability to graph. status is = {}", createCapResult); if (createCapResult.isRight()) { - TitanOperationStatus operationStatus = createCapResult.right().value(); + JanusGraphOperationStatus operationStatus = createCapResult.right().value(); log.error("addCapabilityToGraph - Failed to add capability of type {} to graph. status is {}", capabilityDefinition.getType(), operationStatus); return createCapResult; } @@ -101,14 +102,15 @@ public class CapabilityOperation extends AbstractOperation { return createCapResult; } - private Either connectToCapabilityType(CapabilityData capabilityData, CapabilityTypeData capabilityTypeData) { + private Either connectToCapabilityType(CapabilityData capabilityData, CapabilityTypeData capabilityTypeData) { Map properties = new HashMap<>(); String capabilityName = capabilityData.getCapabilityDataDefinition().getName(); properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), capabilityName); - return titanGenericDao.createRelation(capabilityData, capabilityTypeData, GraphEdgeLabels.CAPABILITY_IMPL, properties); + return janusGraphGenericDao + .createRelation(capabilityData, capabilityTypeData, GraphEdgeLabels.CAPABILITY_IMPL, properties); } @@ -117,13 +119,13 @@ public class CapabilityOperation extends AbstractOperation { * @param capabilites * @return */ - public Either, TitanOperationStatus> getCapabilitiesWithProps(List> capabilites) { - List> listFilledCapabilitiesResults = capabilites.stream() + public Either, JanusGraphOperationStatus> getCapabilitiesWithProps(List> capabilites) { + List> listFilledCapabilitiesResults = capabilites.stream() .map(ImmutablePair::getLeft) .map(this::toCapabilityDefinitionWithProps) .collect(Collectors.toList()); - Optional status = listFilledCapabilitiesResults.stream().filter(Either::isRight) + Optional status = listFilledCapabilitiesResults.stream().filter(Either::isRight) .map(res -> res.right().value()) .findFirst(); @@ -138,7 +140,7 @@ public class CapabilityOperation extends AbstractOperation { return Either.left(listCapabilities); } - private Either toCapabilityDefinitionWithProps(CapabilityData capabilityData) { + private Either toCapabilityDefinitionWithProps(CapabilityData capabilityData) { CapabilityDefinition capabilityDefinition = new CapabilityDefinition(capabilityData.getCapabilityDataDefinition()); return getCapabilityProperties(capabilityDefinition.getUniqueId(), capabilityDefinition.getType()) .left() @@ -157,33 +159,34 @@ public class CapabilityOperation extends AbstractOperation { * @param capabilityUid * @return */ - private Either, TitanOperationStatus> getCapabilityProperties(String capabilityUid, String capabilityType) { - Either capabilityTypeRes = capabilityTypeOperation.getCapabilityTypeByType(capabilityType); + private Either, JanusGraphOperationStatus> getCapabilityProperties(String capabilityUid, String capabilityType) { + Either capabilityTypeRes = capabilityTypeOperation.getCapabilityTypeByType(capabilityType); if (capabilityTypeRes.isRight()) { - TitanOperationStatus status = capabilityTypeRes.right().value(); + JanusGraphOperationStatus status = capabilityTypeRes.right().value(); return Either.right(status); } CapabilityTypeDefinition capabilityTypeDefinition = capabilityTypeRes.left().value(); - Either, TitanOperationStatus> typesPropsRes = getPropertiesOfCapabilityTypeAndAcestors(capabilityTypeDefinition); + Either, JanusGraphOperationStatus> typesPropsRes = getPropertiesOfCapabilityTypeAndAcestors(capabilityTypeDefinition); if (typesPropsRes.isRight()) { - TitanOperationStatus status = typesPropsRes.right().value(); + JanusGraphOperationStatus status = typesPropsRes.right().value(); return Either.right(status); } Map capabilityTypeProperties = typesPropsRes.left().value(); if (isEmpty(capabilityTypeProperties)) { - return Either.right(TitanOperationStatus.OK); + return Either.right(JanusGraphOperationStatus.OK); } Map uidToPropDefMap = capabilityTypeProperties.values().stream() .collect(Collectors.toMap(PropertyDefinition::getUniqueId, Function.identity())); // Find all properties values on the capability - Either>, TitanOperationStatus> propertyValNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Capability), capabilityUid, GraphEdgeLabels.PROPERTY_VALUE, + Either>, JanusGraphOperationStatus> propertyValNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Capability), capabilityUid, GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class); if (propertyValNodes.isRight()) { @@ -192,7 +195,7 @@ public class CapabilityOperation extends AbstractOperation { List> propValsRelationPairs = propertyValNodes.left().value(); if (isEmpty(propValsRelationPairs)) { - return Either.right(TitanOperationStatus.OK); + return Either.right(JanusGraphOperationStatus.OK); } List capabilityProperties = new ArrayList<>(); @@ -200,12 +203,13 @@ public class CapabilityOperation extends AbstractOperation { for (ImmutablePair propValRelPair : propValsRelationPairs) { PropertyValueData propertyValueData = propValRelPair.getLeft(); - Either, TitanOperationStatus> propertyDefRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueData.getUniqueId(), GraphEdgeLabels.PROPERTY_IMPL, + Either, JanusGraphOperationStatus> propertyDefRes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueData.getUniqueId(), GraphEdgeLabels.PROPERTY_IMPL, NodeTypeEnum.Property, PropertyData.class); if (propertyDefRes.isRight()) { - TitanOperationStatus status = propertyDefRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = propertyDefRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -242,8 +246,8 @@ public class CapabilityOperation extends AbstractOperation { .collect(Collectors.toSet()); } - private Either, TitanOperationStatus> onLoadPropValuesFailure(TitanOperationStatus status, Map capabilityTypeProperties) { - if (status == TitanOperationStatus.NOT_FOUND) { + private Either, JanusGraphOperationStatus> onLoadPropValuesFailure(JanusGraphOperationStatus status, Map capabilityTypeProperties) { + if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(buildPropsFromCapabilityTypeProps(capabilityTypeProperties)); } else { return Either.right(status); @@ -267,15 +271,15 @@ public class CapabilityOperation extends AbstractOperation { * @param capabilityTypeDefinition * @return */ - private Either, TitanOperationStatus> getPropertiesOfCapabilityTypeAndAcestors(CapabilityTypeDefinition capabilityTypeDefinition) { + private Either, JanusGraphOperationStatus> getPropertiesOfCapabilityTypeAndAcestors(CapabilityTypeDefinition capabilityTypeDefinition) { // Get the properties on the group type of this capability Map capabilityTypeProperties = capabilityTypeDefinition.getProperties(); String derivedFrom = capabilityTypeDefinition.getDerivedFrom(); if (!Strings.isNullOrEmpty(derivedFrom)) { - Either, TitanOperationStatus> parentPropsRes = capabilityTypeOperation.getAllCapabilityTypePropertiesFromAllDerivedFrom(derivedFrom); + Either, JanusGraphOperationStatus> parentPropsRes = capabilityTypeOperation.getAllCapabilityTypePropertiesFromAllDerivedFrom(derivedFrom); if(parentPropsRes.isRight()) { - TitanOperationStatus status = parentPropsRes.right().value(); + JanusGraphOperationStatus status = parentPropsRes.right().value(); return Either.right(status); } if (capabilityTypeProperties != null) { @@ -297,15 +301,15 @@ public class CapabilityOperation extends AbstractOperation { * @param capabilityTypeData * @return */ - private Either, TitanOperationStatus> createCapabilityProperties(CapabilityData capabilityData, - CapabilityTypeData capabilityTypeData) { + private Either, JanusGraphOperationStatus> createCapabilityProperties(CapabilityData capabilityData, + CapabilityTypeData capabilityTypeData) { CapabilityDefinition capabilityDefintion = (CapabilityDefinition)capabilityData.getCapabilityDataDefinition(); CapabilityTypeDefinition capabilityTypeDefinition = (CapabilityTypeDefinition)capabilityTypeData.getCapabilityTypeDataDefinition(); - Either, TitanOperationStatus> typesPropsRes = getPropertiesOfCapabilityTypeAndAcestors(capabilityTypeDefinition); + Either, JanusGraphOperationStatus> typesPropsRes = getPropertiesOfCapabilityTypeAndAcestors(capabilityTypeDefinition); if (typesPropsRes.isRight()) { - TitanOperationStatus status = typesPropsRes.right().value(); + JanusGraphOperationStatus status = typesPropsRes.right().value(); return Either.right(status); } @@ -313,10 +317,10 @@ public class CapabilityOperation extends AbstractOperation { if (isEmpty(capabilityTypeProperties) && !isEmpty(capabilityDefintion.getProperties())) { log.debug("#createCapabilityProperties - It's not valid if group capability has properties while corresponding capability type doesn't."); - return Either.right(TitanOperationStatus.MATCH_NOT_FOUND); + return Either.right(JanusGraphOperationStatus.MATCH_NOT_FOUND); } - Optional error = capabilityDefintion.getProperties().stream() + Optional error = capabilityDefintion.getProperties().stream() .map(property -> createPropertyValue(property, capabilityData, capabilityTypeProperties.get(property.getName()))) .filter(Either::isRight) .map(result -> result.right().value()) @@ -342,11 +346,11 @@ public class CapabilityOperation extends AbstractOperation { .collect(Collectors.toList()); } - private Either createPropertyValue(ComponentInstanceProperty capabilityProperty, - CapabilityData capabilityData, - PropertyDefinition capTypePropertyDefinition) { + private Either createPropertyValue(ComponentInstanceProperty capabilityProperty, + CapabilityData capabilityData, + PropertyDefinition capTypePropertyDefinition) { if (capTypePropertyDefinition == null) { - return Either.right(TitanOperationStatus.MATCH_NOT_FOUND); + return Either.right(JanusGraphOperationStatus.MATCH_NOT_FOUND); } CapabilityDefinition capabilityDefintion = (CapabilityDefinition)capabilityData.getCapabilityDataDefinition(); @@ -357,7 +361,8 @@ public class CapabilityOperation extends AbstractOperation { PropertyValueData propertyValueData = new PropertyValueData(); propertyValueData.setUniqueId(uniqueId); propertyValueData.setValue(capabilityProperty.getValue()); - Either propResult = titanGenericDao.createNode(propertyValueData, PropertyValueData.class); + Either propResult = janusGraphGenericDao + .createNode(propertyValueData, PropertyValueData.class); // It's not accepted if Capability Type doesn't have suitable property propResult = propResult.left() .bind(propValueData -> connectToProperty(propValueData, capTypePropertyDefinition)) @@ -372,22 +377,23 @@ public class CapabilityOperation extends AbstractOperation { return propResult; } - private Either connectCapability(PropertyValueData propValueData, String name, CapabilityData capabilityData) { + private Either connectCapability(PropertyValueData propValueData, String name, CapabilityData capabilityData) { Map properties = new HashMap<>(); properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), name); - return titanGenericDao.createRelation(capabilityData, propValueData, GraphEdgeLabels.PROPERTY_VALUE, properties); + return janusGraphGenericDao.createRelation(capabilityData, propValueData, GraphEdgeLabels.PROPERTY_VALUE, properties); } - private Either connectToProperty(PropertyValueData propValueData, PropertyDefinition propertyDefinition) { - Either dataTypesRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), + private Either connectToProperty(PropertyValueData propValueData, PropertyDefinition propertyDefinition) { + Either dataTypesRes = janusGraphGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyDefinition.getUniqueId(), PropertyData.class); Map properties = new HashMap<>(); properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), propertyDefinition.getName()); return dataTypesRes.left() - .bind(propertyData -> titanGenericDao.createRelation(propValueData, propertyData, GraphEdgeLabels.PROPERTY_IMPL, properties)); + .bind(propertyData -> janusGraphGenericDao + .createRelation(propValueData, propertyData, GraphEdgeLabels.PROPERTY_IMPL, properties)); } @@ -408,12 +414,14 @@ public class CapabilityOperation extends AbstractOperation { public StorageOperationStatus deleteCapability(CapabilityDefinition capabilityDef) { - return titanGenericDao.deleteChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), capabilityDef.getUniqueId(), GraphEdgeLabels.PROPERTY_VALUE, + return janusGraphGenericDao + .deleteChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), capabilityDef.getUniqueId(), GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class) .left() - .bind(props -> titanGenericDao.deleteNode(new CapabilityData(capabilityDef), CapabilityData.class)) + .bind(props -> janusGraphGenericDao + .deleteNode(new CapabilityData(capabilityDef), CapabilityData.class)) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .right() .on(capData -> StorageOperationStatus.OK); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperation.java index 1cc1380917..61c7e0c13e 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperation.java @@ -30,9 +30,9 @@ import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; import org.openecomp.sdc.be.model.PropertyDefinition; @@ -66,10 +66,10 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab /** * FOR TEST ONLY * - * @param titanGenericDao + * @param janusGraphGenericDao */ - public void setTitanGenericDao(HealingTitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(HealingJanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } @Override @@ -102,26 +102,27 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab if (!inTransaction) { if (result == null || result.isRight()) { log.error("#addCapabilityType - Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("#addCapabilityType - Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } } - public Either, TitanOperationStatus> getAllCapabilityTypePropertiesFromAllDerivedFrom(String firstParentType) { + public Either, JanusGraphOperationStatus> getAllCapabilityTypePropertiesFromAllDerivedFrom(String firstParentType) { return propertyOperation.getAllTypePropertiesFromAllDerivedFrom(firstParentType, NodeTypeEnum.CapabilityType, CapabilityTypeData.class); } public Either validateUpdateProperties(CapabilityTypeDefinition capabilityTypeDefinition) { - TitanOperationStatus error = null; + JanusGraphOperationStatus error = null; if (MapUtils.isNotEmpty(capabilityTypeDefinition.getProperties()) && capabilityTypeDefinition.getDerivedFrom() != null) { - Either, TitanOperationStatus> allPropertiesRes = + Either, JanusGraphOperationStatus> allPropertiesRes = getAllCapabilityTypePropertiesFromAllDerivedFrom(capabilityTypeDefinition.getDerivedFrom()); - if (allPropertiesRes.isRight() && !allPropertiesRes.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + if (allPropertiesRes.isRight() && !allPropertiesRes.right().value().equals( + JanusGraphOperationStatus.NOT_FOUND)) { error = allPropertiesRes.right().value(); log.debug("Couldn't fetch derived from property nodes for capability type {}, error: {}", capabilityTypeDefinition.getType(), error); } @@ -131,7 +132,7 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab .forEach(e -> e.getValue().setType(derivedFromProperties.get(e.getKey()).getType())); List properties = capabilityTypeDefinition.getProperties().values().stream().collect(Collectors.toList()); - Either, TitanOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(), + Either, JanusGraphOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(), properties); if (validatePropertiesRes.isRight()) { error = validatePropertiesRes.right().value(); @@ -141,7 +142,7 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab if (error == null) { return Either.left(capabilityTypeDefinition); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); } @@ -179,21 +180,22 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab CapabilityTypeData capabilityTypeData = buildCapabilityTypeData(capabilityTypeDefinition, ctUniqueId); log.debug("Before adding capability type to graph. capabilityTypeData = {}", capabilityTypeData); - Either createCTResult = titanGenericDao.createNode(capabilityTypeData, CapabilityTypeData.class); + Either createCTResult = janusGraphGenericDao + .createNode(capabilityTypeData, CapabilityTypeData.class); log.debug("After adding capability type to graph. status is = {}", createCTResult); if (createCTResult.isRight()) { - TitanOperationStatus operationStatus = createCTResult.right().value(); + JanusGraphOperationStatus operationStatus = createCTResult.right().value(); log.error("Failed to capability type {} to graph. status is {}", capabilityTypeDefinition.getType(), operationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); } CapabilityTypeData resultCTD = createCTResult.left().value(); Map propertiesMap = capabilityTypeDefinition.getProperties(); - Either, TitanOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.CapabilityType, propertiesMap); + Either, JanusGraphOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.CapabilityType, propertiesMap); if (addPropertiesToCapablityType.isRight()) { log.error("Failed add properties {} to capability {}", propertiesMap, capabilityTypeDefinition.getType()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(addPropertiesToCapablityType.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertiesToCapablityType.right().value())); } return addDerivedFromRelation(capabilityTypeDefinition, ctUniqueId) @@ -223,14 +225,14 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab Either result = null; try { - Either ctResult = this.getCapabilityTypeByUid(uniqueId); + Either ctResult = this.getCapabilityTypeByUid(uniqueId); if (ctResult.isRight()) { - TitanOperationStatus status = ctResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = ctResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { log.error("Failed to retrieve information on capability type {}. status is {}", uniqueId, status); } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(ctResult.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(ctResult.right().value())); return result; } @@ -240,13 +242,13 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab } finally { if (!inTransaction) { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } - public Either getCapabilityTypeByType(String capabilityType) { + public Either getCapabilityTypeByType(String capabilityType) { // Optimization: In case of Capability Type its unique ID is the same as type return getCapabilityTypeByUid(capabilityType); } @@ -257,14 +259,15 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab * @param uniqueId * @return */ - public Either getCapabilityTypeByUid(String uniqueId) { + public Either getCapabilityTypeByUid(String uniqueId) { - Either result = null; + Either result = null; - Either capabilityTypesRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, CapabilityTypeData.class); + Either capabilityTypesRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, CapabilityTypeData.class); if (capabilityTypesRes.isRight()) { - TitanOperationStatus status = capabilityTypesRes.right().value(); + JanusGraphOperationStatus status = capabilityTypesRes.right().value(); log.debug("Capability type {} cannot be found in graph. status is {}", uniqueId, status); return Either.right(status); } @@ -272,9 +275,9 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab CapabilityTypeData ctData = capabilityTypesRes.left().value(); CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition(ctData.getCapabilityTypeDataDefinition()); - Either, TitanOperationStatus> propertiesStatus = + Either, JanusGraphOperationStatus> propertiesStatus = OperationUtils.fillProperties(uniqueId, propertyOperation, NodeTypeEnum.CapabilityType); - if (propertiesStatus.isRight() && propertiesStatus.right().value() != TitanOperationStatus.OK) { + if (propertiesStatus.isRight() && propertiesStatus.right().value() != JanusGraphOperationStatus.OK) { log.error("Failed to fetch properties of capability type {}", uniqueId); return Either.right(propertiesStatus.right().value()); } @@ -283,14 +286,16 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab capabilityTypeDefinition.setProperties(propertiesStatus.left().value()); } - Either, TitanOperationStatus> parentNode = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> parentNode = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.CapabilityType, CapabilityTypeData.class); log.debug("After retrieving DERIVED_FROM node of {}. status is {}", uniqueId, parentNode); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus != TitanOperationStatus.NOT_FOUND) { - log.error("Failed to find the parent capability of capability type {}. status is {}", uniqueId, titanOperationStatus); - result = Either.right(titanOperationStatus); + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) { + log.error("Failed to find the parent capability of capability type {}. status is {}", uniqueId, + janusGraphOperationStatus); + result = Either.right(janusGraphOperationStatus); return result; } } else { @@ -319,9 +324,10 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab private Either updateCapabilityTypeOnGraph(CapabilityTypeDefinition capabilityTypeDefinitionNew, CapabilityTypeDefinition capabilityTypeDefinitionOld) { - return titanGenericDao.updateNode(new CapabilityTypeData(capabilityTypeDefinitionNew), CapabilityTypeData.class) + return janusGraphGenericDao + .updateNode(new CapabilityTypeData(capabilityTypeDefinitionNew), CapabilityTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(updatedNode -> updateProperties(capabilityTypeDefinitionNew.getUniqueId(), capabilityTypeDefinitionNew.getProperties())) .left() @@ -336,7 +342,7 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab log.debug("#updateCapabilityTypeProperties - updating properties for capability type with id {}", capabilityTypeId); return propertyOperation.mergePropertiesAssociatedToNode(NodeTypeEnum.CapabilityType, capabilityTypeId, properties) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } private Either updateDerivedFrom(CapabilityTypeDefinition updatedCapabilityType, String currDerivedFromCapabilityType) { @@ -408,16 +414,17 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab public Either getCapabilityType(String uniqueId) { return getCapabilityType(uniqueId, true); } - public Either, TitanOperationStatus> getAllCapabilityTypes() { + public Either, JanusGraphOperationStatus> getAllCapabilityTypes() { Map capabilityTypes = new HashMap<>(); - Either, TitanOperationStatus> result = Either.left(capabilityTypes); + Either, JanusGraphOperationStatus> result = Either.left(capabilityTypes); - Either, TitanOperationStatus> getAllCapabilityTypes = - titanGenericDao.getByCriteria(NodeTypeEnum.CapabilityType, null, CapabilityTypeData.class); + Either, JanusGraphOperationStatus> getAllCapabilityTypes = + janusGraphGenericDao + .getByCriteria(NodeTypeEnum.CapabilityType, null, CapabilityTypeData.class); if (getAllCapabilityTypes.isRight()) { - TitanOperationStatus status = getAllCapabilityTypes.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = getAllCapabilityTypes.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return Either.right(status); } else { return result; @@ -434,12 +441,12 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab log.trace("Going to fetch data type {}. uid is {}", capabilityTypeData.getCapabilityTypeDataDefinition().getType(), capabilityTypeData.getUniqueId()); - Either capabilityTypesByUid = + Either capabilityTypesByUid = getAndAddPropertiesANdDerivedFrom(capabilityTypeData.getUniqueId(), capabilityTypes); if (capabilityTypesByUid.isRight()) { - TitanOperationStatus status = capabilityTypesByUid.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = capabilityTypesByUid.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -473,18 +480,19 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab return derivedFrom; } - private Either getAndAddPropertiesANdDerivedFrom( + private Either getAndAddPropertiesANdDerivedFrom( String uniqueId, Map capabilityTypeDefinitionMap) { if (capabilityTypeDefinitionMap.containsKey(uniqueId)) { return Either.left(capabilityTypeDefinitionMap.get(uniqueId)); } - Either capabilityTypesRes = - titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, + Either capabilityTypesRes = + janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), uniqueId, CapabilityTypeData.class); if (capabilityTypesRes.isRight()) { - TitanOperationStatus status = capabilityTypesRes.right().value(); + JanusGraphOperationStatus status = capabilityTypesRes.right().value(); log.debug(DATA_TYPE_CANNOT_BE_FOUND_IN_GRAPH_STATUS_IS, uniqueId, status); return Either.right(status); } @@ -493,10 +501,10 @@ public class CapabilityTypeOperation extends AbstractOperation implements ICapab CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition(ctData.getCapabilityTypeDataDefinition()); - Either, TitanOperationStatus> propertiesStatus = + Either, JanusGraphOperationStatus> propertiesStatus = OperationUtils.fillProperties(uniqueId, propertyOperation, NodeTypeEnum.CapabilityType); - if (propertiesStatus.isRight() && propertiesStatus.right().value() != TitanOperationStatus.OK) { + if (propertiesStatus.isRight() && propertiesStatus.right().value() != JanusGraphOperationStatus.OK) { log.error(FAILED_TO_FETCH_PROPERTIES_OF_DATA_TYPE, uniqueId); return Either.right(propertiesStatus.right().value()); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CommonTypeOperations.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CommonTypeOperations.java index 96b083274c..768a96e120 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CommonTypeOperations.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CommonTypeOperations.java @@ -10,9 +10,9 @@ import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Collectors; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.PropertyDefinition; import org.springframework.stereotype.Component; @@ -20,25 +20,25 @@ import org.springframework.stereotype.Component; @Component public class CommonTypeOperations { - private final HealingTitanGenericDao titanGenericDao; + private final HealingJanusGraphGenericDao janusGraphGenericDao; private final PropertyOperation propertyOperation; private final OperationUtils operationUtils; - public CommonTypeOperations(HealingTitanGenericDao titanGenericDao, PropertyOperation propertyOperation, - OperationUtils operationUtils) { - this.titanGenericDao = titanGenericDao; + public CommonTypeOperations(HealingJanusGraphGenericDao janusGraphGenericDao, PropertyOperation propertyOperation, + OperationUtils operationUtils) { + this.janusGraphGenericDao = janusGraphGenericDao; this.propertyOperation = propertyOperation; this.operationUtils = operationUtils; } public void addType(T typeData, Class clazz) { - titanGenericDao.createNode(typeData, clazz) + janusGraphGenericDao.createNode(typeData, clazz) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); } public Optional getType(String uniqueId, Class clazz, NodeTypeEnum nodeType) { - T type = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, clazz) + T type = janusGraphGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, clazz) .left() .on(err -> null); return Optional.ofNullable(type); @@ -48,7 +48,7 @@ public class CommonTypeOperations { Map mapCriteria = new HashMap<>(); mapCriteria.put(GraphPropertiesDictionary.TYPE.getProperty(), type); mapCriteria.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true); - return titanGenericDao.getByCriteria(nodeType, mapCriteria, clazz) + return janusGraphGenericDao.getByCriteria(nodeType, mapCriteria, clazz) .left() .on(err -> emptyList()) .stream() @@ -58,13 +58,14 @@ public class CommonTypeOperations { public void addProperties(String uniqueId, NodeTypeEnum nodeType, List properties) { propertyOperation.addPropertiesToElementType(uniqueId, nodeType, properties) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); } public void fillProperties(String uniqueId, NodeTypeEnum nodeType, Consumer> propertySetter) { - TitanOperationStatus status = propertyOperation.fillPropertiesList(uniqueId, nodeType, propertySetter); - if (status!=TitanOperationStatus.OK) { - operationUtils.onTitanOperationFailure(status); + JanusGraphOperationStatus + status = propertyOperation.fillPropertiesList(uniqueId, nodeType, propertySetter); + if (status!= JanusGraphOperationStatus.OK) { + operationUtils.onJanusGraphOperationFailure(status); } } @@ -72,13 +73,13 @@ public class CommonTypeOperations { * Handle update of type without dervidedFrom attribute */ public void updateType(T typeData, List properties, Class clazz, NodeTypeEnum nodeType) { - titanGenericDao.updateNode(typeData, clazz) + janusGraphGenericDao.updateNode(typeData, clazz) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); Map newProperties = properties.stream() .collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())); propertyOperation.mergePropertiesAssociatedToNode(nodeType, typeData.getUniqueId(), newProperties) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java index 34dce75c7d..91b4e0a0ce 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java @@ -20,8 +20,8 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import java.util.HashMap; import java.util.Map; @@ -35,11 +35,11 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -83,10 +83,10 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo /** * FOR TEST ONLY * - * @param titanGenericDao + * @param janusGraphGenericDao */ - public void setTitanGenericDao(HealingTitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(HealingJanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } @Override @@ -95,19 +95,20 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo Either result = null; try { - Either graphResult = titanGenericDao.getGraph(); + Either graphResult = janusGraphGenericDao.getGraph(); if (graphResult.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graphResult.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graphResult.right().value())); return result; } - Either vertexService = titanGenericDao.getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId); + Either vertexService = janusGraphGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId); if (vertexService.isRight()) { log.debug("failed to fetch vertex of resource instance for id = {}", resourceInstanceId); - TitanOperationStatus status = vertexService.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = vertexService.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexService.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexService.right().value())); return result; } Vertex vertex = vertexService.left().value(); @@ -130,34 +131,36 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo if (!inTransaction) { if (result == null || result.isRight()) { log.error("increaseAndGetResourceInstanceSpecificCounter operation : Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("increaseAndGetResourceInstanceSpecificCounter operation : Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } } - private void connectAttValueDataToComponentInstanceData(Wrapper errorWrapper, ComponentInstanceData compIns, AttributeValueData attValueData) { + private void connectAttValueDataToComponentInstanceData(Wrapper errorWrapper, ComponentInstanceData compIns, AttributeValueData attValueData) { - Either createRelResult = titanGenericDao.createRelation(compIns, attValueData, GraphEdgeLabels.ATTRIBUTE_VALUE, null); + Either createRelResult = janusGraphGenericDao + .createRelation(compIns, attValueData, GraphEdgeLabels.ATTRIBUTE_VALUE, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); errorWrapper.setInnerElement(operationStatus); BeEcompErrorManager.getInstance().logInternalFlowError("connectAttValueDataToComponentInstanceData", "Failed to associate resource instance " + compIns.getUniqueId() + " attribute value " + attValueData.getUniqueId() + " in graph. status is " + operationStatus, ErrorSeverity.ERROR); } } - private void connectAttValueDataToAttData(Wrapper errorWrapper, AttributeData attData, AttributeValueData attValueData) { + private void connectAttValueDataToAttData(Wrapper errorWrapper, AttributeData attData, AttributeValueData attValueData) { - Either createRelResult = titanGenericDao.createRelation(attValueData, attData, GraphEdgeLabels.ATTRIBUTE_IMPL, null); + Either createRelResult = janusGraphGenericDao + .createRelation(attValueData, attData, GraphEdgeLabels.ATTRIBUTE_IMPL, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError("connectAttValueDataToAttData", "Failed to associate attribute value " + attValueData.getUniqueId() + " to attribute " + attData.getUniqueId() + " in graph. status is " + operationStatus, ErrorSeverity.ERROR); @@ -165,8 +168,8 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } } - private void createAttributeValueDataNode(ComponentInstanceProperty attributeInstanceProperty, Integer index, Wrapper errorWrapper, ComponentInstanceData resourceInstanceData, - Wrapper attValueDataWrapper) { + private void createAttributeValueDataNode(ComponentInstanceProperty attributeInstanceProperty, Integer index, Wrapper errorWrapper, ComponentInstanceData resourceInstanceData, + Wrapper attValueDataWrapper) { String valueUniqueUid = attributeInstanceProperty.getValueUniqueUid(); if (valueUniqueUid == null) { @@ -174,11 +177,12 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo AttributeValueData attributeValueData = buildAttributeValueDataFromComponentInstanceAttribute(attributeInstanceProperty, attValueDatauniqueId); log.debug("Before adding attribute value to graph {}", attributeValueData); - Either createNodeResult = titanGenericDao.createNode(attributeValueData, AttributeValueData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(attributeValueData, AttributeValueData.class); log.debug("After adding attribute value to graph {}", attributeValueData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); errorWrapper.setInnerElement(operationStatus); } else { attValueDataWrapper.setInnerElement(createNodeResult.left().value()); @@ -186,7 +190,7 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } else { BeEcompErrorManager.getInstance().logInternalFlowError("CreateAttributeValueDataNode", "attribute value already exists.", ErrorSeverity.ERROR); - errorWrapper.setInnerElement(TitanOperationStatus.ALREADY_EXIST); + errorWrapper.setInnerElement(JanusGraphOperationStatus.ALREADY_EXIST); } } @@ -258,10 +262,10 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo * @param resourceInstanceId * @return */ - private Either updateAttributeOfResourceInstance(ComponentInstanceProperty resourceInstanceAttribute, String resourceInstanceId) { + private Either updateAttributeOfResourceInstance(ComponentInstanceProperty resourceInstanceAttribute, String resourceInstanceId) { - Either result = null; - Wrapper errorWrapper = new Wrapper<>(); + Either result = null; + Wrapper errorWrapper = new Wrapper<>(); UpdateDataContainer updateDataContainer = new UpdateDataContainer<>(GraphEdgeLabels.ATTRIBUTE_IMPL, (() -> AttributeData.class), (() -> AttributeValueData.class), NodeTypeEnum.Attribute, NodeTypeEnum.AttributeValue); preUpdateElementOfResourceInstanceValidations(updateDataContainer, resourceInstanceAttribute, resourceInstanceId, errorWrapper); @@ -269,9 +273,10 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo AttributeValueData attributeValueData = updateDataContainer.getValueDataWrapper().getInnerElement(); attributeValueData.setHidden(resourceInstanceAttribute.isHidden()); attributeValueData.setValue(resourceInstanceAttribute.getValue()); - Either updateRes = titanGenericDao.updateNode(attributeValueData, AttributeValueData.class); + Either updateRes = janusGraphGenericDao + .updateNode(attributeValueData, AttributeValueData.class); if (updateRes.isRight()) { - TitanOperationStatus status = updateRes.right().value(); + JanusGraphOperationStatus status = updateRes.right().value(); errorWrapper.setInnerElement(status); } else { result = Either.left(updateRes.left().value()); @@ -284,8 +289,8 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } - private Either addAttributeToResourceInstance(ComponentInstanceProperty attributeInstanceProperty, String resourceInstanceId, Integer index) { - Wrapper errorWrapper = new Wrapper<>(); + private Either addAttributeToResourceInstance(ComponentInstanceProperty attributeInstanceProperty, String resourceInstanceId, Integer index) { + Wrapper errorWrapper = new Wrapper<>(); Wrapper compInsWrapper = new Wrapper<>(); Wrapper attDataWrapper = new Wrapper<>(); Wrapper attValueDataWrapper = new Wrapper<>(); @@ -320,7 +325,7 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } private void preUpdateElementOfResourceInstanceValidations(UpdateDataContainer updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty, - String resourceInstanceId, Wrapper errorWrapper) { + String resourceInstanceId, Wrapper errorWrapper) { if (errorWrapper.isEmpty()) { // Verify VFC instance Exist @@ -344,14 +349,15 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } private void validateElementConnectedToInstance(UpdateDataContainer updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty, - Wrapper errorWrapper) { - Either, TitanOperationStatus> child = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), resourceInstanceProerty.getValueUniqueUid(), + Wrapper errorWrapper) { + Either, JanusGraphOperationStatus> child = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), resourceInstanceProerty.getValueUniqueUid(), updateDataContainer.getGraphEdge(), updateDataContainer.getNodeType(), updateDataContainer.getSomeDataClassGen().get()); if (child.isRight()) { - TitanOperationStatus status = child.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = child.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); @@ -361,16 +367,17 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } private void validateElementConnectedToComponentInstanceExist(UpdateDataContainer updateDataContainer, - IComponentInstanceConnectedElement resourceInstanceProerty, Wrapper errorWrapper) { + IComponentInstanceConnectedElement resourceInstanceProerty, Wrapper errorWrapper) { String valueUniqueUid = resourceInstanceProerty.getValueUniqueUid(); if (valueUniqueUid == null) { - errorWrapper.setInnerElement(TitanOperationStatus.INVALID_ID); + errorWrapper.setInnerElement(JanusGraphOperationStatus.INVALID_ID); } else { - Either findPropertyValueRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), valueUniqueUid, updateDataContainer.getSomeValueDataClassGen().get()); + Either findPropertyValueRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), valueUniqueUid, updateDataContainer.getSomeValueDataClassGen().get()); if (findPropertyValueRes.isRight()) { - TitanOperationStatus status = findPropertyValueRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findPropertyValueRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); } else { @@ -380,31 +387,33 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo } private void validateElementConnectedToComponentExist(UpdateDataContainer updateDataContainer, - IComponentInstanceConnectedElement resourceInstanceElementConnected, Wrapper errorWrapper) { + IComponentInstanceConnectedElement resourceInstanceElementConnected, Wrapper errorWrapper) { String uniqueId = resourceInstanceElementConnected.getUniqueId(); - Either findPropertyDefRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeType()), uniqueId, updateDataContainer.getSomeDataClassGen().get()); + Either findPropertyDefRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeType()), uniqueId, updateDataContainer.getSomeDataClassGen().get()); if (findPropertyDefRes.isRight()) { - TitanOperationStatus status = findPropertyDefRes.right().value(); + JanusGraphOperationStatus status = findPropertyDefRes.right().value(); errorWrapper.setInnerElement(status); } } - private void validateRIExist(String resourceInstanceId, Wrapper errorWrapper) { + private void validateRIExist(String resourceInstanceId, Wrapper errorWrapper) { validateRIExist(resourceInstanceId, null, errorWrapper); } - private void validateRIExist(String resourceInstanceId, Wrapper compInsDataWrapper, Wrapper errorWrapper) { + private void validateRIExist(String resourceInstanceId, Wrapper compInsDataWrapper, Wrapper errorWrapper) { validateElementExistInGraph(resourceInstanceId, NodeTypeEnum.ResourceInstance, () -> ComponentInstanceData.class, compInsDataWrapper, errorWrapper); } public void validateElementExistInGraph(String elementUniqueId, NodeTypeEnum elementNodeType, Supplier> elementClassGen, Wrapper elementDataWrapper, - Wrapper errorWrapper) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(elementNodeType), elementUniqueId, elementClassGen.get()); + Wrapper errorWrapper) { + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(elementNodeType), elementUniqueId, elementClassGen.get()); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); } else { @@ -421,25 +430,27 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo * @param index * @return */ - private Either addInputToResourceInstance(ComponentInstanceInput resourceInstanceInput, String resourceInstanceId, Integer index) { + private Either addInputToResourceInstance(ComponentInstanceInput resourceInstanceInput, String resourceInstanceId, Integer index) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, ComponentInstanceData.class); + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, ComponentInstanceData.class); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } String propertyId = resourceInstanceInput.getUniqueId(); - Either findPropertyDefRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Input), propertyId, InputsData.class); + Either findPropertyDefRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Input), propertyId, InputsData.class); if (findPropertyDefRes.isRight()) { - TitanOperationStatus status = findPropertyDefRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findPropertyDefRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -451,13 +462,13 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo ComponentInstanceData resourceInstanceData = findResInstanceRes.left().value(); - ImmutablePair isInputValueExists = inputOperation.findInputValue(resourceInstanceId, propertyId); - if (isInputValueExists.getLeft() == TitanOperationStatus.ALREADY_EXIST) { + ImmutablePair isInputValueExists = inputOperation.findInputValue(resourceInstanceId, propertyId); + if (isInputValueExists.getLeft() == JanusGraphOperationStatus.ALREADY_EXIST) { log.debug("The property {} already added to the resource instance {}", propertyId, resourceInstanceId); resourceInstanceInput.setValueUniqueUid(isInputValueExists.getRight()); } - if (isInputValueExists.getLeft() != TitanOperationStatus.NOT_FOUND) { + if (isInputValueExists.getLeft() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("After finding input value of {} on componenet instance {}", propertyId, resourceInstanceId); return Either.right(isInputValueExists.getLeft()); } @@ -473,20 +484,20 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo SchemaDefinition def = propDataDef.getSchema(); if (def == null) { log.debug("Schema doesn't exists for property of type {}", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } PropertyDataDefinition propDef = def.getProperty(); if (propDef == null) { log.debug("Property in Schema Definition inside property of type {} doesn't exist", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } innerType = propDef.getType(); } log.debug("Before validateAndUpdatePropertyValue"); - Either, TitanOperationStatus> allDataTypes = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll(); if (allDataTypes.isRight()) { - TitanOperationStatus status = allDataTypes.right().value(); + JanusGraphOperationStatus status = allDataTypes.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR); return Either.right(status); } @@ -501,21 +512,23 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo log.debug("After validateAndUpdateRules. pair = {} ", pair); if (pair.getRight() != null && !pair.getRight()) { BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), resourceInstanceInput.getName(), propertyType); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } log.debug("Before adding property value to graph {}", propertyValueData); - Either createNodeResult = titanGenericDao.createNode(propertyValueData, InputValueData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(propertyValueData, InputValueData.class); log.debug("After adding property value to graph {}", propertyValueData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); return Either.right(operationStatus); } - Either createRelResult = titanGenericDao.createRelation(propertyValueData, propertyData, GraphEdgeLabels.INPUT_IMPL, null); + Either createRelResult = janusGraphGenericDao + .createRelation(propertyValueData, propertyData, GraphEdgeLabels.INPUT_IMPL, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate property value {} to property {} in graph. status is {}", uniqueId, propertyId, operationStatus); return Either.right(operationStatus); } @@ -525,10 +538,11 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo properties1.put(GraphEdgePropertiesDictionary.NAME.getProperty(), resourceInstanceData.getComponentInstDataDefinition().getName()); properties1.put(GraphEdgePropertiesDictionary.OWNER_ID.getProperty(), resourceInstanceData.getComponentInstDataDefinition().getUniqueId()); - createRelResult = titanGenericDao.createRelation(resourceInstanceData, propertyValueData, GraphEdgeLabels.INPUT_VALUE, properties1); + createRelResult = janusGraphGenericDao + .createRelation(resourceInstanceData, propertyValueData, GraphEdgeLabels.INPUT_VALUE, properties1); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to associate resource instance {} property value {} in graph. status is {}", resourceInstanceId, uniqueId, operationStatus); return Either.right(operationStatus); @@ -537,7 +551,7 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo return Either.left(createNodeResult.left().value()); } else { log.error("property value already exists."); - return Either.right(TitanOperationStatus.ALREADY_EXIST); + return Either.right(JanusGraphOperationStatus.ALREADY_EXIST); } } @@ -548,11 +562,11 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo try { - Either eitherStatus = this.addAttributeToResourceInstance(resourceInstanceAttribute, resourceInstanceId, index); + Either eitherStatus = this.addAttributeToResourceInstance(resourceInstanceAttribute, resourceInstanceId, index); if (eitherStatus.isRight()) { log.error("Failed to add attribute value {} to resource instance {} in Graph. status is {}", resourceInstanceAttribute, resourceInstanceId, eitherStatus.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); return result; } else { AttributeValueData attributeValueData = eitherStatus.left().value(); @@ -582,11 +596,11 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo Either result = null; try { - Either eitherAttributeValue = updateAttributeOfResourceInstance(resourceInstanceAttribute, resourceInstanceId); + Either eitherAttributeValue = updateAttributeOfResourceInstance(resourceInstanceAttribute, resourceInstanceId); if (eitherAttributeValue.isRight()) { log.error("Failed to add attribute value {} to resource instance {} in Graph. status is {}", resourceInstanceAttribute, resourceInstanceId, eitherAttributeValue.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherAttributeValue.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherAttributeValue.right().value())); return result; } else { AttributeValueData attributeValueData = eitherAttributeValue.left().value(); @@ -618,11 +632,11 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo try { - Either eitherStatus = addInputToResourceInstance(resourceInstanceInput, resourceInstanceId, index); + Either eitherStatus = addInputToResourceInstance(resourceInstanceInput, resourceInstanceId, index); if (eitherStatus.isRight()) { log.error("Failed to add input value {} to resource instance {} in Graph. status is {}", resourceInstanceInput, resourceInstanceId, eitherStatus.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); return result; } else { InputValueData propertyValueData = eitherStatus.left().value(); @@ -630,9 +644,9 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo ComponentInstanceInput propertyValueResult = inputOperation.buildResourceInstanceInput(propertyValueData, resourceInstanceInput); log.debug("The returned ResourceInstanceProperty is {}", propertyValueResult); - Either findDefaultValue = propertyOperation.findDefaultValueFromSecondPosition(resourceInstanceInput.getPath(), resourceInstanceInput.getUniqueId(), resourceInstanceInput.getDefaultValue()); + Either findDefaultValue = propertyOperation.findDefaultValueFromSecondPosition(resourceInstanceInput.getPath(), resourceInstanceInput.getUniqueId(), resourceInstanceInput.getDefaultValue()); if (findDefaultValue.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(findDefaultValue.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findDefaultValue.right().value())); return result; } String defaultValue = findDefaultValue.left().value(); @@ -648,10 +662,10 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -665,13 +679,13 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo @Override public StorageOperationStatus updateCustomizationUUID(String componentInstanceId) { - Either vertexByProperty = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), componentInstanceId); + Either vertexByProperty = janusGraphGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), componentInstanceId); if (vertexByProperty.isRight()) { log.debug("Failed to fetch component instance by id {} error {}", componentInstanceId, vertexByProperty.right().value()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(vertexByProperty.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexByProperty.right().value()); } UUID uuid = UUID.randomUUID(); - TitanVertex ciVertex = vertexByProperty.left().value(); + JanusGraphVertex ciVertex = vertexByProperty.left().value(); ciVertex.property(GraphPropertiesDictionary.CUSTOMIZATION_UUID.getProperty(), uuid.toString()); return StorageOperationStatus.OK; @@ -686,10 +700,11 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo ComponentInstanceData componentData = new ComponentInstanceData(componentInstance, componentInstance.getGroupInstances().size()); componentData.getComponentInstDataDefinition().setModificationTime(modificationTime); componentData.getComponentInstDataDefinition().setCustomizationUUID(UUID.randomUUID().toString()); - Either updateNode = titanGenericDao.updateNode(componentData, ComponentInstanceData.class); + Either updateNode = janusGraphGenericDao + .updateNode(componentData, ComponentInstanceData.class); if (updateNode.isRight()) { log.error("Failed to update resource {}. status is {}", componentInstance.getUniqueId(), updateNode.right().value()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value())); }else{ result = Either.left(updateNode.left().value()); } @@ -700,10 +715,10 @@ public class ComponentInstanceOperation extends AbstractOperation implements ICo if(!inTransaction){ if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ConsumerOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ConsumerOperation.java index c173b59020..b429071572 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ConsumerOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ConsumerOperation.java @@ -21,9 +21,9 @@ package org.openecomp.sdc.be.model.operations.impl; import fj.data.Either; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.operations.api.IConsumerOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -38,23 +38,25 @@ import java.util.List; @Component("consumer-operation") public class ConsumerOperation implements IConsumerOperation { - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; private static final Logger log = Logger.getLogger(ConsumerOperation.class.getName()); - public ConsumerOperation(@Qualifier("titan-generic-dao") TitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public ConsumerOperation(@Qualifier("janusgraph-generic-dao") + JanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } @Override public Either getCredentials(String consumerName) { Either result = null; log.debug("retriving Credentials for: {}", consumerName); - Either getNode = titanGenericDao.getNode(GraphPropertiesDictionary.CONSUMER_NAME.getProperty(), consumerName, ConsumerData.class); + Either getNode = janusGraphGenericDao + .getNode(GraphPropertiesDictionary.CONSUMER_NAME.getProperty(), consumerName, ConsumerData.class); if (getNode.isRight()) { - TitanOperationStatus status = getNode.right().value(); + JanusGraphOperationStatus status = getNode.right().value(); log.error("Error returned after get Consumer Data node {}. status returned is {}", consumerName, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } ConsumerData consumerData = getNode.left().value(); @@ -64,8 +66,9 @@ public class ConsumerOperation implements IConsumerOperation { @Override public Either, StorageOperationStatus> getAll() { log.debug("retrieving all consumers"); - return titanGenericDao.getByCriteria(NodeTypeEnum.ConsumerCredentials, Collections.emptyMap(), ConsumerData.class) - .right().map(DaoStatusConverter::convertTitanStatusToStorageStatus); + return janusGraphGenericDao + .getByCriteria(NodeTypeEnum.ConsumerCredentials, Collections.emptyMap(), ConsumerData.class) + .right().map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } @Override @@ -78,11 +81,12 @@ public class ConsumerOperation implements IConsumerOperation { Either result = null; try { log.debug("creating Credentials for: {}", consumerData.getUniqueId()); - Either createNode = titanGenericDao.createNode(consumerData, ConsumerData.class); + Either createNode = janusGraphGenericDao + .createNode(consumerData, ConsumerData.class); if (createNode.isRight()) { - TitanOperationStatus status = createNode.right().value(); + JanusGraphOperationStatus status = createNode.right().value(); log.error("Error returned after creating Consumer Data node {}. status returned is {}", consumerData.getUniqueId(), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } ConsumerData createdConsumerData = createNode.left().value(); @@ -103,11 +107,12 @@ public class ConsumerOperation implements IConsumerOperation { Either result = null; try { log.debug("delete Credentials for: {}", consumerName); - Either deleteNode = titanGenericDao.deleteNode(GraphPropertiesDictionary.CONSUMER_NAME.getProperty(), consumerName, ConsumerData.class); + Either deleteNode = janusGraphGenericDao + .deleteNode(GraphPropertiesDictionary.CONSUMER_NAME.getProperty(), consumerName, ConsumerData.class); if (deleteNode.isRight()) { - TitanOperationStatus status = deleteNode.right().value(); + JanusGraphOperationStatus status = deleteNode.right().value(); log.error("Error returned after delete Consumer Data node {}. status returned is {}", consumerName, status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } @@ -131,11 +136,12 @@ public class ConsumerOperation implements IConsumerOperation { Either result = null; try { log.debug("update Credentials for: {}", consumerData.getUniqueId()); - Either updateNode = titanGenericDao.updateNode(consumerData, ConsumerData.class); + Either updateNode = janusGraphGenericDao + .updateNode(consumerData, ConsumerData.class); if (updateNode.isRight()) { - TitanOperationStatus status = updateNode.right().value(); + JanusGraphOperationStatus status = updateNode.right().value(); log.error("Error returned after delete Consumer Data node {}. status returned is {}", consumerData.getUniqueId(), status); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } ConsumerData updatedConsumerData = updateNode.left().value(); @@ -150,10 +156,10 @@ public class ConsumerOperation implements IConsumerOperation { if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DaoStatusConverter.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DaoStatusConverter.java index a66dce139b..bce7a2a73c 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DaoStatusConverter.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DaoStatusConverter.java @@ -21,18 +21,18 @@ package org.openecomp.sdc.be.model.operations.impl; import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; public class DaoStatusConverter { - public static StorageOperationStatus convertTitanStatusToStorageStatus(TitanOperationStatus titanStatus) { + public static StorageOperationStatus convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus janusGraphStatus) { - if (titanStatus == null) { + if (janusGraphStatus == null) { return StorageOperationStatus.GENERAL_ERROR; } - switch (titanStatus) { + switch (janusGraphStatus) { case OK: return StorageOperationStatus.OK; @@ -54,7 +54,7 @@ public class DaoStatusConverter { case ALREADY_LOCKED: return StorageOperationStatus.FAILED_TO_LOCK_ELEMENT; - case TITAN_SCHEMA_VIOLATION: + case JANUSGRAPH_SCHEMA_VIOLATION: return StorageOperationStatus.SCHEMA_VIOLATION; case INVALID_ID: diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DefaultDerivedFromOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DefaultDerivedFromOperation.java index 6f9555899b..e39f4b8f5a 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DefaultDerivedFromOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DefaultDerivedFromOperation.java @@ -6,10 +6,10 @@ import org.apache.commons.lang3.tuple.Pair; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -24,27 +24,28 @@ import java.util.function.Function; public class DefaultDerivedFromOperation implements DerivedFromOperation { private static final Logger log = Logger.getLogger(DefaultDerivedFromOperation.class.getName()); - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; - public DefaultDerivedFromOperation(TitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public DefaultDerivedFromOperation(JanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } @Override public Either addDerivedFromRelation(String parentUniqueId, String derivedFromUniqueId, NodeTypeEnum nodeType) { UniqueIdData from = new UniqueIdData(nodeType, parentUniqueId); UniqueIdData to = new UniqueIdData(nodeType, derivedFromUniqueId); - return titanGenericDao.createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null) + return janusGraphGenericDao.createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } @Override public Either getDerivedFromChild(String uniqueId, NodeTypeEnum nodeType, Class clazz) { log.debug("#getDerivedFromChild - fetching derived from entity for node type {} with id {}", nodeType, uniqueId); - return titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.DERIVED_FROM, nodeType, clazz) + return janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.DERIVED_FROM, nodeType, clazz) .bimap(Pair::getKey, - DaoStatusConverter::convertTitanStatusToStorageStatus); + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } @Override @@ -53,19 +54,19 @@ public class DefaultDerivedFromOperation implements DerivedFromOperation { UniqueIdData to = new UniqueIdData(nodeType, derivedFromUniqueId); return isDerivedFromExists(from, to) .either(isRelationExist -> isRelationExist ? deleteDerivedFrom(from, to) : StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } private StorageOperationStatus deleteDerivedFrom(UniqueIdData from, UniqueIdData to) { - return titanGenericDao.deleteRelation(from, to, GraphEdgeLabels.DERIVED_FROM) + return janusGraphGenericDao.deleteRelation(from, to, GraphEdgeLabels.DERIVED_FROM) .either(deletedRelation -> StorageOperationStatus.OK, - DaoStatusConverter::convertTitanStatusToStorageStatus); + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } - private Either isDerivedFromExists(UniqueIdData from, UniqueIdData to) { - return titanGenericDao.isRelationExist(from, to, GraphEdgeLabels.DERIVED_FROM); + private Either isDerivedFromExists(UniqueIdData from, UniqueIdData to) { + return janusGraphGenericDao.isRelationExist(from, to, GraphEdgeLabels.DERIVED_FROM); } @Override @@ -74,11 +75,14 @@ public class DefaultDerivedFromOperation implements DerivedFromOperation { Map propertiesToMatch = new HashMap<>(); propertiesToMatch.put(GraphPropertiesDictionary.TYPE.getProperty(), childCandidateType); - Either, TitanOperationStatus> getResponse = titanGenericDao.getByCriteria(nodeType, propertiesToMatch, clazz); + Either, JanusGraphOperationStatus> getResponse = janusGraphGenericDao + .getByCriteria(nodeType, propertiesToMatch, clazz); if (getResponse.isRight()) { - TitanOperationStatus titanOperationStatus = getResponse.right().value(); - log.debug("Couldn't fetch type {}, error: {}", childCandidateType, titanOperationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value(); + log.debug("Couldn't fetch type {}, error: {}", childCandidateType, + janusGraphOperationStatus); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } T node = getResponse.left().value().get(0); String childUniqueId = node.getUniqueId(); @@ -91,13 +95,16 @@ public class DefaultDerivedFromOperation implements DerivedFromOperation { do { travelledTypes.add(childType); - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), childUniqueId, GraphEdgeLabels.DERIVED_FROM, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), childUniqueId, GraphEdgeLabels.DERIVED_FROM, nodeType, clazz); if (childrenNodes.isRight()) { - if (childrenNodes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus titanOperationStatus = getResponse.right().value(); - log.debug("Couldn't fetch derived from node for type {}, error: {}", childCandidateType, titanOperationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + if (childrenNodes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value(); + log.debug("Couldn't fetch derived from node for type {}, error: {}", childCandidateType, + janusGraphOperationStatus); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } else { log.debug("Derived from node is not found for type {} - this is OK for root capability.", childCandidateType); return Either.left(false); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ElementOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ElementOperation.java index fd455bcde8..ce9d320ed7 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ElementOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ElementOperation.java @@ -20,8 +20,8 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Vertex; @@ -31,10 +31,10 @@ import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.category.CategoryDataDefinition; import org.openecomp.sdc.be.datatypes.category.GroupingDataDefinition; import org.openecomp.sdc.be.datatypes.category.SubCategoryDataDefinition; @@ -62,13 +62,14 @@ import java.util.*; @Component("element-operation") public class ElementOperation implements IElementOperation { - private static final String COULDN_T_FETCH_TITAN_GRAPH = "Couldn't fetch titan graph"; + private static final String COULDN_T_FETCH_janusGraph_GRAPH = "Couldn't fetch janusgraph graph"; private static final String UNKNOWN_CATEGORY_TYPE = "Unknown category type {}"; - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; - public ElementOperation(@Qualifier("titan-generic-dao") TitanGenericDao titanGenericDao) { + public ElementOperation(@Qualifier("janusgraph-generic-dao") + JanusGraphGenericDao janusGraphGenericDao) { super(); - this.titanGenericDao = titanGenericDao; + this.janusGraphGenericDao = janusGraphGenericDao; } private static final Logger log = Logger.getLogger(ElementOperation.class.getName()); @@ -109,12 +110,13 @@ public class ElementOperation implements IElementOperation { CategoryData categoryData = new CategoryData(nodeType, category); try { - Either createNode = titanGenericDao.createNode(categoryData, CategoryData.class); + Either createNode = janusGraphGenericDao + .createNode(categoryData, CategoryData.class); if (createNode.isRight()) { - TitanOperationStatus value = createNode.right().value(); + JanusGraphOperationStatus value = createNode.right().value(); ActionStatus actionStatus = ActionStatus.GENERAL_ERROR; log.debug("Problem while creating category, reason {}", value); - if (value == TitanOperationStatus.TITAN_SCHEMA_VIOLATION) { + if (value == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) { actionStatus = ActionStatus.COMPONENT_CATEGORY_ALREADY_EXISTS; } result = Either.right(actionStatus); @@ -126,9 +128,9 @@ public class ElementOperation implements IElementOperation { } finally { if (!inTransaction) { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } } @@ -146,12 +148,13 @@ public class ElementOperation implements IElementOperation { try { // create edge from category to sub-category - Either categoryNode = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); + Either categoryNode = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); ActionStatus actionStatus = ActionStatus.GENERAL_ERROR; if (categoryNode.isRight()) { - TitanOperationStatus titanOperationStatus = categoryNode.right().value(); - log.debug("Problem while fetching category, reason {}", titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = categoryNode.right().value(); + log.debug("Problem while fetching category, reason {}", janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { actionStatus = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND; } result = Either.right(actionStatus); @@ -162,18 +165,20 @@ public class ElementOperation implements IElementOperation { subCategory.setUniqueId(UniqueIdBuilder.buildSubCategoryUid(categoryDataDefinition.getUniqueId(), subCategory.getNormalizedName())); SubCategoryData subCategoryData = new SubCategoryData(nodeType, subCategory); - Either subCategoryNode = titanGenericDao.createNode(subCategoryData, SubCategoryData.class); + Either subCategoryNode = janusGraphGenericDao + .createNode(subCategoryData, SubCategoryData.class); if (subCategoryNode.isRight()) { - TitanOperationStatus titanOperationStatus = subCategoryNode.right().value(); - log.debug("Problem while creating category, reason {}", titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.TITAN_SCHEMA_VIOLATION) { + JanusGraphOperationStatus janusGraphOperationStatus = subCategoryNode.right().value(); + log.debug("Problem while creating category, reason {}", janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) { actionStatus = ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY; } result = Either.right(actionStatus); return result; } - Either relation = titanGenericDao.createRelation(categoryNode.left().value(), subCategoryNode.left().value(), GraphEdgeLabels.SUB_CATEGORY, null); + Either relation = janusGraphGenericDao + .createRelation(categoryNode.left().value(), subCategoryNode.left().value(), GraphEdgeLabels.SUB_CATEGORY, null); if (relation.isRight()) { log.debug("Problem while create relation between category and sub-category ", relation.right().value()); result = Either.right(actionStatus); @@ -185,9 +190,9 @@ public class ElementOperation implements IElementOperation { } finally { if (!inTransaction) { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } } @@ -200,12 +205,13 @@ public class ElementOperation implements IElementOperation { try { // create edge from sub-category to grouping - Either subCategoryNode = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); + Either subCategoryNode = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); ActionStatus actionStatus = ActionStatus.GENERAL_ERROR; if (subCategoryNode.isRight()) { - TitanOperationStatus titanOperationStatus = subCategoryNode.right().value(); - log.debug("Problem while fetching category, reason {}", titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.TITAN_SCHEMA_VIOLATION) { + JanusGraphOperationStatus janusGraphOperationStatus = subCategoryNode.right().value(); + log.debug("Problem while fetching category, reason {}", janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) { actionStatus = ActionStatus.COMPONENT_CATEGORY_NOT_FOUND; } result = Either.right(actionStatus); @@ -216,18 +222,20 @@ public class ElementOperation implements IElementOperation { grouping.setUniqueId(UniqueIdBuilder.buildGroupingUid(subCatData.getUniqueId(), grouping.getNormalizedName())); GroupingData groupingData = new GroupingData(nodeType, grouping); - Either groupingNode = titanGenericDao.createNode(groupingData, GroupingData.class); + Either groupingNode = janusGraphGenericDao + .createNode(groupingData, GroupingData.class); if (groupingNode.isRight()) { - TitanOperationStatus titanOperationStatus = groupingNode.right().value(); - log.debug("Problem while creating grouping, reason {}", titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = groupingNode.right().value(); + log.debug("Problem while creating grouping, reason {}", janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { actionStatus = ActionStatus.COMPONENT_GROUPING_EXISTS_FOR_SUB_CATEGORY; } result = Either.right(actionStatus); return result; } - Either relation = titanGenericDao.createRelation(subCategoryNode.left().value(), groupingNode.left().value(), GraphEdgeLabels.GROUPING, null); + Either relation = janusGraphGenericDao + .createRelation(subCategoryNode.left().value(), groupingNode.left().value(), GraphEdgeLabels.GROUPING, null); if (relation.isRight()) { log.debug("Problem while create relation between sub-category and grouping", relation.right().value()); result = Either.right(actionStatus); @@ -238,9 +246,9 @@ public class ElementOperation implements IElementOperation { return result; } finally { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } } @@ -253,8 +261,9 @@ public class ElementOperation implements IElementOperation { return Either.right(ActionStatus.GENERAL_ERROR); } - Either, TitanOperationStatus> either = titanGenericDao.getAll(nodeType, org.openecomp.sdc.be.resources.data.category.CategoryData.class); - if (either.isRight() && (either.right().value() != TitanOperationStatus.NOT_FOUND)) { + Either, JanusGraphOperationStatus> either = janusGraphGenericDao + .getAll(nodeType, org.openecomp.sdc.be.resources.data.category.CategoryData.class); + if (either.isRight() && (either.right().value() != JanusGraphOperationStatus.NOT_FOUND)) { log.debug("Problem while get all categories. reason - {}", either.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -267,8 +276,9 @@ public class ElementOperation implements IElementOperation { CategoryDefinition categoryDefinition = new CategoryDefinition(categoryDataDefinition); String categoryName = categoryDataDefinition.getName(); log.trace("Found category {}, category type {}", categoryName, nodeType); - TitanOperationStatus setSubCategories = setSubCategories(nodeType, categoryDefinition); - if (setSubCategories != TitanOperationStatus.OK) { + JanusGraphOperationStatus + setSubCategories = setSubCategories(nodeType, categoryDefinition); + if (setSubCategories != JanusGraphOperationStatus.OK) { log.debug("Failed to set sub-categories for category {}, category type {}, error {}", categoryName, nodeType, setSubCategories); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -278,25 +288,26 @@ public class ElementOperation implements IElementOperation { return Either.left(categoryList); } finally { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } - private TitanOperationStatus setSubCategories(NodeTypeEnum parentNodeType, CategoryDefinition parentCategory) { + private JanusGraphOperationStatus setSubCategories(NodeTypeEnum parentNodeType, CategoryDefinition parentCategory) { NodeTypeEnum childNodeType = getChildNodeType(parentNodeType); if (childNodeType != null) { String categoryName = parentCategory.getName(); log.trace("Getting sub-categories for category {}, category type {}", categoryName, parentNodeType); - Either>, TitanOperationStatus> parentNode = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentCategory.getUniqueId(), GraphEdgeLabels.SUB_CATEGORY, + Either>, JanusGraphOperationStatus> parentNode = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentCategory.getUniqueId(), GraphEdgeLabels.SUB_CATEGORY, childNodeType, SubCategoryData.class); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { log.trace("Didn't find subcategories for category {}, category type {}", categoryName, parentNodeType); - titanOperationStatus = TitanOperationStatus.OK; + janusGraphOperationStatus = JanusGraphOperationStatus.OK; } - return titanOperationStatus; + return janusGraphOperationStatus; } List> subsCategoriesData = parentNode.left().value(); List subCategoriesDefinitions = new ArrayList<>(); @@ -305,32 +316,34 @@ public class ElementOperation implements IElementOperation { SubCategoryDefinition subCategoryDefinition = new SubCategoryDefinition(subCategoryDataDefinition); log.trace("Found sub-category {} for category {}, category type {}", subCategoryDataDefinition.getName(), categoryName, parentNodeType); - TitanOperationStatus setGroupings = setGroupings(childNodeType, subCategoryDefinition); - if (setGroupings != TitanOperationStatus.OK) { + JanusGraphOperationStatus + setGroupings = setGroupings(childNodeType, subCategoryDefinition); + if (setGroupings != JanusGraphOperationStatus.OK) { log.debug("Failed to set groupings for sub-category {}, sub-category type {}, error {}", subCategoryDataDefinition.getName(), childNodeType, setGroupings); - return TitanOperationStatus.GENERAL_ERROR; + return JanusGraphOperationStatus.GENERAL_ERROR; } subCategoriesDefinitions.add(subCategoryDefinition); } parentCategory.setSubcategories(subCategoriesDefinitions); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - private TitanOperationStatus setGroupings(NodeTypeEnum parentNodeType, SubCategoryDefinition parentSubCategory) { + private JanusGraphOperationStatus setGroupings(NodeTypeEnum parentNodeType, SubCategoryDefinition parentSubCategory) { NodeTypeEnum childNodeType = getChildNodeType(parentNodeType); if (childNodeType != null) { String subCategoryName = parentSubCategory.getName(); log.trace("Getting groupings for subcategory {}, subcategory type {}", subCategoryName, parentNodeType); - Either>, TitanOperationStatus> parentNode = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentSubCategory.getUniqueId(), GraphEdgeLabels.GROUPING, + Either>, JanusGraphOperationStatus> parentNode = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentSubCategory.getUniqueId(), GraphEdgeLabels.GROUPING, childNodeType, GroupingData.class); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { log.trace("Didn't find groupings for subcategory {}, subcategory type {}", subCategoryName, parentNodeType); - titanOperationStatus = TitanOperationStatus.OK; + janusGraphOperationStatus = JanusGraphOperationStatus.OK; } - return titanOperationStatus; + return janusGraphOperationStatus; } List> groupingData = parentNode.left().value(); List groupingDefinitions = new ArrayList<>(); @@ -341,7 +354,7 @@ public class ElementOperation implements IElementOperation { } parentSubCategory.setGroupings(groupingDefinitions); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } private static NodeTypeEnum getChildNodeType(NodeTypeEnum parentTypeEnum) { @@ -370,11 +383,13 @@ public class ElementOperation implements IElementOperation { return Either.right(ActionStatus.GENERAL_ERROR); } - Either categoryDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); + Either categoryDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); if (categoryDataEither.isRight()) { - TitanOperationStatus titanOperationStatus = categoryDataEither.right().value(); - log.debug("Problem while get category by id {}. reason {}", categoryId, titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = categoryDataEither.right().value(); + log.debug("Problem while get category by id {}. reason {}", categoryId, + janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND); } return Either.right(ActionStatus.GENERAL_ERROR); @@ -382,7 +397,7 @@ public class ElementOperation implements IElementOperation { CategoryDataDefinition categoryDataDefinition = categoryDataEither.left().value().getCategoryDataDefinition(); return Either.left(new CategoryDefinition(categoryDataDefinition)); } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -394,11 +409,13 @@ public class ElementOperation implements IElementOperation { return Either.right(ActionStatus.GENERAL_ERROR); } - Either subCategoryDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); + Either subCategoryDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); if (subCategoryDataEither.isRight()) { - TitanOperationStatus titanOperationStatus = subCategoryDataEither.right().value(); - log.debug("Problem while get sub-category by id {}. reason {}", subCategoryId, titanOperationStatus); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = subCategoryDataEither.right().value(); + log.debug("Problem while get sub-category by id {}. reason {}", subCategoryId, + janusGraphOperationStatus); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND); } return Either.right(ActionStatus.GENERAL_ERROR); @@ -406,7 +423,7 @@ public class ElementOperation implements IElementOperation { SubCategoryDataDefinition subCategoryDataDefinition = subCategoryDataEither.left().value().getSubCategoryDataDefinition(); return Either.left(new SubCategoryDefinition(subCategoryDataDefinition)); } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -419,24 +436,25 @@ public class ElementOperation implements IElementOperation { result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either categoryDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); + Either categoryDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId, CategoryData.class); if (categoryDataEither.isRight()) { log.debug("Failed to retrieve category for id {} ", categoryId); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { - log.debug(COULDN_T_FETCH_TITAN_GRAPH); + log.debug(COULDN_T_FETCH_janusGraph_GRAPH); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); - Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId).vertices(); - Iterator iterator = verticesArtifact.iterator(); + Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), categoryId).vertices(); + Iterator iterator = verticesArtifact.iterator(); if (!iterator.hasNext()) { log.debug("No category node for id = {}", categoryId); result = Either.right(ActionStatus.GENERAL_ERROR); @@ -449,9 +467,9 @@ public class ElementOperation implements IElementOperation { return result; } finally { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } } @@ -465,24 +483,25 @@ public class ElementOperation implements IElementOperation { result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either subCategoryDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); + Either subCategoryDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); if (subCategoryDataEither.isRight()) { log.debug("Failed to retrieve sub-category for id {}", subCategoryId); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { - log.debug(COULDN_T_FETCH_TITAN_GRAPH); + log.debug(COULDN_T_FETCH_janusGraph_GRAPH); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); - Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId).vertices(); - Iterator iterator = verticesArtifact.iterator(); + Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId).vertices(); + Iterator iterator = verticesArtifact.iterator(); if (!iterator.hasNext()) { log.debug("No sub-category node for id {}", subCategoryId); result = Either.right(ActionStatus.GENERAL_ERROR); @@ -496,9 +515,9 @@ public class ElementOperation implements IElementOperation { return result; } finally { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } @@ -513,24 +532,25 @@ public class ElementOperation implements IElementOperation { result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either groupingDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class); + Either groupingDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class); if (groupingDataEither.isRight()) { log.debug("Failed to retrieve grouping for id {}", groupingId); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { - log.debug(COULDN_T_FETCH_TITAN_GRAPH); + log.debug(COULDN_T_FETCH_janusGraph_GRAPH); result = Either.right(ActionStatus.GENERAL_ERROR); return result; } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); - Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId).vertices(); - Iterator iterator = verticesArtifact.iterator(); + Iterable verticesArtifact = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId).vertices(); + Iterator iterator = verticesArtifact.iterator(); if (!iterator.hasNext()) { log.debug("No grouping node for id {}", groupingId); result = Either.right(ActionStatus.GENERAL_ERROR); @@ -544,9 +564,9 @@ public class ElementOperation implements IElementOperation { return result; } finally { if (result != null && result.isLeft()) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } else { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } } } @@ -557,8 +577,9 @@ public class ElementOperation implements IElementOperation { Map properties = new HashMap<>(); properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), normalizedName); try { - Either, TitanOperationStatus> categoryEither = titanGenericDao.getByCriteria(nodeType, properties, CategoryData.class); - if (categoryEither.isRight() && categoryEither.right().value() != TitanOperationStatus.NOT_FOUND) { + Either, JanusGraphOperationStatus> categoryEither = janusGraphGenericDao + .getByCriteria(nodeType, properties, CategoryData.class); + if (categoryEither.isRight() && categoryEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to get categories, nodeType {}, normalizedName {}, error {}", nodeType, normalizedName, categoryEither.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -575,7 +596,7 @@ public class ElementOperation implements IElementOperation { return Either.left(true); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -584,8 +605,9 @@ public class ElementOperation implements IElementOperation { String subCategoryId = UniqueIdBuilder.buildSubCategoryUid(parentCategoryId, subCategoryNormName); try { - Either subCategoryDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); - if (subCategoryDataEither.isRight() && subCategoryDataEither.right().value() != TitanOperationStatus.NOT_FOUND) { + Either subCategoryDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), subCategoryId, SubCategoryData.class); + if (subCategoryDataEither.isRight() && subCategoryDataEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to get sub-category with id {}, error {}", subCategoryId, subCategoryDataEither.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -598,7 +620,7 @@ public class ElementOperation implements IElementOperation { return Either.left(true); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -607,8 +629,9 @@ public class ElementOperation implements IElementOperation { String groupingId = UniqueIdBuilder.buildGroupingUid(parentSubCategoryId, groupingNormName); try { - Either groupingDataEither = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class); - if (groupingDataEither.isRight() && groupingDataEither.right().value() != TitanOperationStatus.NOT_FOUND) { + Either groupingDataEither = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), groupingId, GroupingData.class); + if (groupingDataEither.isRight() && groupingDataEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to get grouping with id {}, error {}", groupingId, groupingDataEither.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -621,7 +644,7 @@ public class ElementOperation implements IElementOperation { return Either.left(true); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -630,8 +653,9 @@ public class ElementOperation implements IElementOperation { Map properties = new HashMap<>(); properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), normalizedName); try { - Either, TitanOperationStatus> subCategoryEither = titanGenericDao.getByCriteria(nodeType, properties, SubCategoryData.class); - if (subCategoryEither.isRight() && subCategoryEither.right().value() != TitanOperationStatus.NOT_FOUND) { + Either, JanusGraphOperationStatus> subCategoryEither = janusGraphGenericDao + .getByCriteria(nodeType, properties, SubCategoryData.class); + if (subCategoryEither.isRight() && subCategoryEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to get sub-categories, nodeType {}, normalizedName {}, error {}", nodeType, normalizedName, subCategoryEither.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -646,7 +670,7 @@ public class ElementOperation implements IElementOperation { return Either.left(null); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -655,8 +679,9 @@ public class ElementOperation implements IElementOperation { Map properties = new HashMap<>(); properties.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), groupingNormalizedName); try { - Either, TitanOperationStatus> groupingEither = titanGenericDao.getByCriteria(nodeType, properties, GroupingData.class); - if (groupingEither.isRight() && groupingEither.right().value() != TitanOperationStatus.NOT_FOUND) { + Either, JanusGraphOperationStatus> groupingEither = janusGraphGenericDao + .getByCriteria(nodeType, properties, GroupingData.class); + if (groupingEither.isRight() && groupingEither.right().value() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("Failed to get grouping, nodeType {}, normalizedName {}, error {}", nodeType, groupingNormalizedName, groupingEither.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); } @@ -671,7 +696,7 @@ public class ElementOperation implements IElementOperation { return Either.left(null); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -682,7 +707,8 @@ public class ElementOperation implements IElementOperation { @Override public Either, ActionStatus> getAllTags() { try { - Either, TitanOperationStatus> either = titanGenericDao.getAll(NodeTypeEnum.Tag, TagData.class); + Either, JanusGraphOperationStatus> either = janusGraphGenericDao + .getAll(NodeTypeEnum.Tag, TagData.class); if (either.isRight()) { log.debug("Problem while get all tags. reason - {}", either.right().value()); return Either.right(ActionStatus.GENERAL_ERROR); @@ -691,7 +717,7 @@ public class ElementOperation implements IElementOperation { List tagList = convertToListOfTag(tagDataList); return Either.left(tagList); } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -708,12 +734,14 @@ public class ElementOperation implements IElementOperation { } else { categoryUid = UniqueIdBuilder.buildServiceCategoryUid(name, type); } - Either either = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(type), categoryUid, clazz); + Either either = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(type), categoryUid, clazz); if (either.isRight()) { - TitanOperationStatus titanOperationStatus = either.right().value(); - log.debug("Problem while geting category with id {}. reason - {}", categoryUid, titanOperationStatus.name()); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = either.right().value(); + log.debug("Problem while geting category with id {}. reason - {}", categoryUid, janusGraphOperationStatus + .name()); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND); } else { return Either.right(StorageOperationStatus.GENERAL_ERROR); @@ -804,12 +832,14 @@ public class ElementOperation implements IElementOperation { String categoryUid = UniqueIdBuilder.buildServiceCategoryUid(name, type); Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normalizeCategoryName4Uniqueness(name)); - Either, TitanOperationStatus> either = titanGenericDao.getByCriteria(type, props, clazz); + Either, JanusGraphOperationStatus> either = janusGraphGenericDao + .getByCriteria(type, props, clazz); if (either.isRight()) { - TitanOperationStatus titanOperationStatus = either.right().value(); - log.debug("Problem while geting category with id {}. reason - {}", categoryUid, titanOperationStatus.name()); - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = either.right().value(); + log.debug("Problem while geting category with id {}. reason - {}", categoryUid, janusGraphOperationStatus + .name()); + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(StorageOperationStatus.CATEGORY_NOT_FOUND); } else { return Either.right(StorageOperationStatus.GENERAL_ERROR); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GraphLockOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GraphLockOperation.java index b87da5ad9a..009f375a13 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GraphLockOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GraphLockOperation.java @@ -20,8 +20,8 @@ package org.openecomp.sdc.be.model.operations.impl; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -33,7 +33,7 @@ public class GraphLockOperation implements IGraphLockOperation { private static final Logger log = Logger.getLogger(GraphLockOperation.class.getName()); @javax.annotation.Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; public GraphLockOperation() { super(); @@ -47,15 +47,15 @@ public class GraphLockOperation implements IGraphLockOperation { @Override public StorageOperationStatus lockComponent(String componentId, NodeTypeEnum nodeType) { log.info("lock resource with id {}", componentId); - TitanOperationStatus lockElementStatus = null; + JanusGraphOperationStatus lockElementStatus = null; try { - lockElementStatus = titanGenericDao.lockElement(componentId, nodeType); + lockElementStatus = janusGraphGenericDao.lockElement(componentId, nodeType); } catch (Exception e) { - lockElementStatus = TitanOperationStatus.ALREADY_LOCKED; + lockElementStatus = JanusGraphOperationStatus.ALREADY_LOCKED; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(lockElementStatus); } @@ -66,30 +66,32 @@ public class GraphLockOperation implements IGraphLockOperation { */ @Override public StorageOperationStatus unlockComponent(String componentId, NodeTypeEnum nodeType) { - TitanOperationStatus lockElementStatus = titanGenericDao.releaseElement(componentId, nodeType); - return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus); + JanusGraphOperationStatus lockElementStatus = janusGraphGenericDao + .releaseElement(componentId, nodeType); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(lockElementStatus); } @Override public StorageOperationStatus unlockComponentByName(String name, String componentId, NodeTypeEnum nodeType) { - TitanOperationStatus lockElementStatus = titanGenericDao.releaseElement(name, nodeType); - return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus); + JanusGraphOperationStatus + lockElementStatus = janusGraphGenericDao.releaseElement(name, nodeType); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(lockElementStatus); } @Override public StorageOperationStatus lockComponentByName(String name, NodeTypeEnum nodeType) { log.info("lock resource with name {}", name); - TitanOperationStatus lockElementStatus = null; + JanusGraphOperationStatus lockElementStatus = null; try { - lockElementStatus = titanGenericDao.lockElement(name, nodeType); + lockElementStatus = janusGraphGenericDao.lockElement(name, nodeType); } catch (Exception e) { - lockElementStatus = TitanOperationStatus.ALREADY_LOCKED; + lockElementStatus = JanusGraphOperationStatus.ALREADY_LOCKED; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(lockElementStatus); } } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java index 4c86af45e5..39d4c73afb 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java @@ -20,8 +20,8 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang3.tuple.ImmutablePair; @@ -31,9 +31,9 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; @@ -74,37 +74,38 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI Either, StorageOperationStatus> result = null; List groupInstanceRes = new ArrayList<>(); - Either graph = titanGenericDao.getGraph(); + Either graph = janusGraphGenericDao.getGraph(); if (graph.isRight()) { log.debug("Failed to work with graph {}", graph.right().value()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graph.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graph.right().value())); } - TitanGraph tGraph = graph.left().value(); + JanusGraph tGraph = graph.left().value(); @SuppressWarnings("unchecked") - Iterable vertices = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(parentType), parentId).vertices(); + Iterable vertices = tGraph.query().has(UniqueIdBuilder.getKeyByNodeType(parentType), parentId).vertices(); if (vertices == null || vertices.iterator() == null || !vertices.iterator().hasNext()) { log.debug("No nodes for type {} for id = {}", parentType, parentId); result = Either.right(StorageOperationStatus.NOT_FOUND); return result; } - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); Vertex vertex = iterator.next(); Map edgeProperties = null; - Either>, TitanOperationStatus> childrenByEdgeCriteria = titanGenericDao.getChildrenByEdgeCriteria(vertex, parentId, GraphEdgeLabels.GROUP_INST, NodeTypeEnum.GroupInstance, + Either>, JanusGraphOperationStatus> childrenByEdgeCriteria = janusGraphGenericDao + .getChildrenByEdgeCriteria(vertex, parentId, GraphEdgeLabels.GROUP_INST, NodeTypeEnum.GroupInstance, GroupInstanceData.class, edgeProperties); if (childrenByEdgeCriteria.isRight()) { - TitanOperationStatus status = childrenByEdgeCriteria.right().value(); + JanusGraphOperationStatus status = childrenByEdgeCriteria.right().value(); log.debug("Failed to find group instance {} on graph", childrenByEdgeCriteria.right().value()); - if (status == TitanOperationStatus.NOT_FOUND) { + if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(groupInstanceRes); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } List> list = childrenByEdgeCriteria.left().value(); @@ -120,16 +121,16 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } GroupDefinition groupDefinition = groupRes.left().value(); - Either, TitanOperationStatus> groupInstancePropertyValuesRes = getAllGroupInstancePropertyValuesData(groupInstData); + Either, JanusGraphOperationStatus> groupInstancePropertyValuesRes = getAllGroupInstancePropertyValuesData(groupInstData); if(groupInstancePropertyValuesRes.isRight()){ - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(groupInstancePropertyValuesRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(groupInstancePropertyValuesRes.right().value())); } buildGroupInstanceFromGroup(groupInstance, groupDefinition, groupInstancePropertyValuesRes.left().value()); - Either>, TitanOperationStatus> artifactsRes = getGroupArtifactsPairs(groupInstance.getUniqueId()); + Either>, JanusGraphOperationStatus> artifactsRes = getGroupArtifactsPairs(groupInstance.getUniqueId()); if (artifactsRes.isRight()) { - TitanOperationStatus status = artifactsRes.right().value(); - if (status != TitanOperationStatus.OK) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + JanusGraphOperationStatus status = artifactsRes.right().value(); + if (status != JanusGraphOperationStatus.OK) { + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); return result; } } else { @@ -175,11 +176,11 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI try { - Either eitherStatus = addPropertyToGroupInstance(groupInstanceProperty, groupInstanceId, index); + Either eitherStatus = addPropertyToGroupInstance(groupInstanceProperty, groupInstanceId, index); if (eitherStatus.isRight()) { log.error("Failed to add property value {} to resource instance {} in Graph. status is {}", groupInstanceProperty, groupInstanceId, eitherStatus.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); return result; } else { PropertyValueData propertyValueData = eitherStatus.left().value(); @@ -187,9 +188,9 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI ComponentInstanceProperty propertyValueResult = propertyOperation.buildResourceInstanceProperty(propertyValueData, groupInstanceProperty); log.debug("The returned GroupInstanceProperty is {}", propertyValueResult); - Either findDefaultValue = propertyOperation.findDefaultValueFromSecondPosition(groupInstanceProperty.getPath(), groupInstanceProperty.getUniqueId(), groupInstanceProperty.getDefaultValue()); + Either findDefaultValue = propertyOperation.findDefaultValueFromSecondPosition(groupInstanceProperty.getPath(), groupInstanceProperty.getUniqueId(), groupInstanceProperty.getDefaultValue()); if (findDefaultValue.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(findDefaultValue.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findDefaultValue.right().value())); return result; } String defaultValue = findDefaultValue.left().value(); @@ -205,10 +206,10 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -233,25 +234,27 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI * @param index * @return */ - public Either addPropertyToGroupInstance(ComponentInstanceProperty groupInstanceProperty, String groupInstanceId, Integer index) { + public Either addPropertyToGroupInstance(ComponentInstanceProperty groupInstanceProperty, String groupInstanceId, Integer index) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupInstance), groupInstanceId, GroupInstanceData.class); + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupInstance), groupInstanceId, GroupInstanceData.class); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } String propertyId = groupInstanceProperty.getUniqueId(); - Either findPropertyDefRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); + Either findPropertyDefRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); if (findPropertyDefRes.isRight()) { - TitanOperationStatus status = findPropertyDefRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findPropertyDefRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -262,11 +265,11 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI PropertyData propertyData = findPropertyDefRes.left().value(); GroupInstanceData resourceInstanceData = findResInstanceRes.left().value(); - ImmutablePair isPropertyValueExists = propertyOperation.findPropertyValue(groupInstanceId, propertyId); - if (isPropertyValueExists.getLeft() == TitanOperationStatus.ALREADY_EXIST) { + ImmutablePair isPropertyValueExists = propertyOperation.findPropertyValue(groupInstanceId, propertyId); + if (isPropertyValueExists.getLeft() == JanusGraphOperationStatus.ALREADY_EXIST) { log.debug("The property {} already added to the resource instance {}", propertyId, groupInstanceId); groupInstanceProperty.setValueUniqueUid(isPropertyValueExists.getRight()); - Either updatePropertyOfResourceInstance = updatePropertyOfGroupInstance(groupInstanceProperty, groupInstanceId); + Either updatePropertyOfResourceInstance = updatePropertyOfGroupInstance(groupInstanceProperty, groupInstanceId); if (updatePropertyOfResourceInstance.isRight()) { BeEcompErrorManager.getInstance().logInternalFlowError(UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE, FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS + updatePropertyOfResourceInstance.right().value(), ErrorSeverity.ERROR); return Either.right(updatePropertyOfResourceInstance.right().value()); @@ -274,7 +277,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI return Either.left(updatePropertyOfResourceInstance.left().value()); } - if (isPropertyValueExists.getLeft() != TitanOperationStatus.NOT_FOUND) { + if (isPropertyValueExists.getLeft() != JanusGraphOperationStatus.NOT_FOUND) { log.debug("After finding property value of {} on componenet instance {}", propertyId, groupInstanceId); return Either.right(isPropertyValueExists.getLeft()); } @@ -290,20 +293,20 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI SchemaDefinition def = propDataDef.getSchema(); if (def == null) { log.debug("Schema doesn't exists for property of type {}", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } PropertyDataDefinition propDef = def.getProperty(); if (propDef == null) { log.debug("Property in Schema Definition inside property of type {} doesn't exist", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } innerType = propDef.getType(); } log.debug("Before validateAndUpdatePropertyValue"); - Either, TitanOperationStatus> allDataTypes = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll(); if (allDataTypes.isRight()) { - TitanOperationStatus status = allDataTypes.right().value(); + JanusGraphOperationStatus status = allDataTypes.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError(UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE, FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS + status, ErrorSeverity.ERROR); return Either.right(status); } @@ -314,7 +317,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI if (isValid.isRight()) { Boolean res = isValid.right().value(); if (!res) { - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } } else { Object object = isValid.left().value(); @@ -333,32 +336,35 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI log.debug("After validateAndUpdateRules. pair = {}", pair); if (pair.getRight() != null && !pair.getRight()) { BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), groupInstanceProperty.getName(), propertyType); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } propertyOperation.addRulesToNewPropertyValue(propertyValueData, groupInstanceProperty, groupInstanceId); log.debug("Before adding property value to graph {}", propertyValueData); - Either createNodeResult = titanGenericDao.createNode(propertyValueData, PropertyValueData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(propertyValueData, PropertyValueData.class); log.debug("After adding property value to graph {}", propertyValueData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); return Either.right(operationStatus); } propertyValueData = createNodeResult.left().value(); - Either createRelResult = titanGenericDao.createRelation(propertyValueData, propertyData, GraphEdgeLabels.PROPERTY_IMPL, null); + Either createRelResult = janusGraphGenericDao + .createRelation(propertyValueData, propertyData, GraphEdgeLabels.PROPERTY_IMPL, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate property value {} to property {} in graph. status is {}", uniqueId, propertyId, operationStatus); return Either.right(operationStatus); } - createRelResult = titanGenericDao.createRelation(resourceInstanceData, propertyValueData, GraphEdgeLabels.PROPERTY_VALUE, null); + createRelResult = janusGraphGenericDao + .createRelation(resourceInstanceData, propertyValueData, GraphEdgeLabels.PROPERTY_VALUE, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate resource instance {} property value {} in graph. status is {}", groupInstanceId, uniqueId, operationStatus); return Either.right(operationStatus); } @@ -366,7 +372,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI return Either.left(propertyValueData); } else { log.error("property value already exists."); - return Either.right(TitanOperationStatus.ALREADY_EXIST); + return Either.right(JanusGraphOperationStatus.ALREADY_EXIST); } } @@ -376,9 +382,9 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI * * @return */ - public Either updatePropertyOfGroupInstance(ComponentInstanceProperty groupInstanceProerty, String groupInstanceId) { + public Either updatePropertyOfGroupInstance(ComponentInstanceProperty groupInstanceProerty, String groupInstanceId) { - Wrapper errorWrapper = new Wrapper<>(); + Wrapper errorWrapper = new Wrapper<>(); UpdateDataContainer updateDataContainer = new UpdateDataContainer<>(GraphEdgeLabels.PROPERTY_IMPL, (() -> PropertyData.class), (() -> PropertyValueData.class), NodeTypeEnum.Property, NodeTypeEnum.PropertyValue); @@ -403,19 +409,19 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI SchemaDefinition def = propDataDef.getSchema(); if (def == null) { log.debug("Schema doesn't exists for property of type {}", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } PropertyDataDefinition propDef = def.getProperty(); if (propDef == null) { log.debug("Property in Schema Definition inside property of type {} doesn't exist", type); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } innerType = propDef.getType(); } // Specific Update Logic - Either, TitanOperationStatus> allDataTypes = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll(); if (allDataTypes.isRight()) { - TitanOperationStatus status = allDataTypes.right().value(); + JanusGraphOperationStatus status = allDataTypes.right().value(); BeEcompErrorManager.getInstance().logInternalFlowError(UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE, FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS + status, ErrorSeverity.ERROR); return Either.right(status); } @@ -425,7 +431,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI if (isValid.isRight()) { Boolean res = isValid.right().value(); if (!res) { - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } } else { Object object = isValid.left().value(); @@ -440,13 +446,14 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI ImmutablePair pair = propertyOperation.validateAndUpdateRules(propertyType, groupInstanceProerty.getRules(), innerType, allDataTypes.left().value(), true); if (pair.getRight() != null && !pair.getRight()) { BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), groupInstanceProerty.getName(), propertyType); - return Either.right(TitanOperationStatus.ILLEGAL_ARGUMENT); + return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT); } propertyOperation.updateRulesInPropertyValue(propertyValueData, groupInstanceProerty, groupInstanceId); - Either updateRes = titanGenericDao.updateNode(propertyValueData, PropertyValueData.class); + Either updateRes = janusGraphGenericDao + .updateNode(propertyValueData, PropertyValueData.class); if (updateRes.isRight()) { - TitanOperationStatus status = updateRes.right().value(); + JanusGraphOperationStatus status = updateRes.right().value(); return Either.right(status); } else { return Either.left(updateRes.left().value()); @@ -505,7 +512,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } private void preUpdateElementOfResourceInstanceValidations(UpdateDataContainer updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty, - String resourceInstanceId, Wrapper errorWrapper) { + String resourceInstanceId, Wrapper errorWrapper) { if (errorWrapper.isEmpty()) { // Verify VFC instance Exist @@ -529,14 +536,15 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } private void validateElementConnectedToInstance(UpdateDataContainer updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty, - Wrapper errorWrapper) { - Either, TitanOperationStatus> child = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), resourceInstanceProerty.getValueUniqueUid(), + Wrapper errorWrapper) { + Either, JanusGraphOperationStatus> child = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), resourceInstanceProerty.getValueUniqueUid(), updateDataContainer.getGraphEdge(), updateDataContainer.getNodeType(), updateDataContainer.getSomeDataClassGen().get()); if (child.isRight()) { - TitanOperationStatus status = child.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = child.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); @@ -546,16 +554,17 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } private void validateElementConnectedToComponentInstanceExist(UpdateDataContainer updateDataContainer, - IComponentInstanceConnectedElement resourceInstanceProerty, Wrapper errorWrapper) { + IComponentInstanceConnectedElement resourceInstanceProerty, Wrapper errorWrapper) { String valueUniqueUid = resourceInstanceProerty.getValueUniqueUid(); if (valueUniqueUid == null) { - errorWrapper.setInnerElement(TitanOperationStatus.INVALID_ID); + errorWrapper.setInnerElement(JanusGraphOperationStatus.INVALID_ID); } else { - Either findPropertyValueRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), valueUniqueUid, updateDataContainer.getSomeValueDataClassGen().get()); + Either findPropertyValueRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), valueUniqueUid, updateDataContainer.getSomeValueDataClassGen().get()); if (findPropertyValueRes.isRight()) { - TitanOperationStatus status = findPropertyValueRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findPropertyValueRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); } else { @@ -565,31 +574,33 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } private void validateElementConnectedToComponentExist(UpdateDataContainer updateDataContainer, - IComponentInstanceConnectedElement resourceInstanceElementConnected, Wrapper errorWrapper) { + IComponentInstanceConnectedElement resourceInstanceElementConnected, Wrapper errorWrapper) { String uniqueId = resourceInstanceElementConnected.getUniqueId(); - Either findPropertyDefRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeType()), uniqueId, updateDataContainer.getSomeDataClassGen().get()); + Either findPropertyDefRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeType()), uniqueId, updateDataContainer.getSomeDataClassGen().get()); if (findPropertyDefRes.isRight()) { - TitanOperationStatus status = findPropertyDefRes.right().value(); + JanusGraphOperationStatus status = findPropertyDefRes.right().value(); errorWrapper.setInnerElement(status); } } - private void validateGIExist(String resourceInstanceId, Wrapper errorWrapper) { + private void validateGIExist(String resourceInstanceId, Wrapper errorWrapper) { validateGIExist(resourceInstanceId, null, errorWrapper); } - private void validateGIExist(String resourceInstanceId, Wrapper compInsDataWrapper, Wrapper errorWrapper) { + private void validateGIExist(String resourceInstanceId, Wrapper compInsDataWrapper, Wrapper errorWrapper) { validateElementExistInGraph(resourceInstanceId, NodeTypeEnum.GroupInstance, () -> GroupInstanceData.class, compInsDataWrapper, errorWrapper); } public void validateElementExistInGraph(String elementUniqueId, NodeTypeEnum elementNodeType, Supplier> elementClassGen, Wrapper elementDataWrapper, - Wrapper errorWrapper) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(elementNodeType), elementUniqueId, elementClassGen.get()); + Wrapper errorWrapper) { + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(elementNodeType), elementUniqueId, elementClassGen.get()); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } errorWrapper.setInnerElement(status); } else { @@ -627,16 +638,17 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI return updatedProperty; } - private Either>, TitanOperationStatus> getGroupArtifactsPairs(String groupUniqueId) { + private Either>, JanusGraphOperationStatus> getGroupArtifactsPairs(String groupUniqueId) { - Either>, TitanOperationStatus> result = null; + Either>, JanusGraphOperationStatus> result = null; - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupInstance), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupInstance), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class); if (childrenNodes.isRight()) { - TitanOperationStatus status = childrenNodes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childrenNodes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } result = Either.right(status); @@ -696,24 +708,26 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI for (GroupInstance groupDefinition : associatedGroups) { UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.GroupInstance, groupDefinition.getUniqueId()); - Either deleteRelation = titanGenericDao.deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF); + Either deleteRelation = janusGraphGenericDao + .deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF); log.trace("After dissociate group {} from artifact {}", groupDefinition.getName(), oldArtifactId); if (deleteRelation.isRight()) { - TitanOperationStatus status = deleteRelation.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = deleteRelation.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } - Either createRelation = titanGenericDao.createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props); + Either createRelation = janusGraphGenericDao + .createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props); log.trace("After associate group {} to artifact {}", groupDefinition.getName(), newArtifact.getUniqueIdKey()); if (createRelation.isRight()) { - TitanOperationStatus status = createRelation.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = createRelation.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } } @@ -721,17 +735,17 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI return StorageOperationStatus.OK; } - private Either, TitanOperationStatus> getAllGroupInstancePropertyValuesData(GroupInstanceData groupInstData) { + private Either, JanusGraphOperationStatus> getAllGroupInstancePropertyValuesData(GroupInstanceData groupInstData) { - Either, TitanOperationStatus> result = null; + Either, JanusGraphOperationStatus> result = null; try{ - Either>, TitanOperationStatus> getPropertyValueChildrenRes = - titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), groupInstData.getUniqueId(), GraphEdgeLabels.PROPERTY_VALUE, + Either>, JanusGraphOperationStatus> getPropertyValueChildrenRes = + janusGraphGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), groupInstData.getUniqueId(), GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class, true); if(getPropertyValueChildrenRes.isRight()){ - TitanOperationStatus status = getPropertyValueChildrenRes.right().value(); + JanusGraphOperationStatus status = getPropertyValueChildrenRes.right().value(); log.debug("Failed to fetch property value nodes for group instance {}. Status is {}. ", groupInstData.getName(), status); - if(status == TitanOperationStatus.NOT_FOUND){ + if(status == JanusGraphOperationStatus.NOT_FOUND){ result = Either.left(null); }else{ result = Either.right(status); @@ -743,7 +757,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI } catch(Exception e){ log.debug("The Exception occured during fetch group instance () property values. The message is {}. ", groupInstData.getName(), e.getMessage(), e); if(result == null){ - result = Either.right(TitanOperationStatus.GENERAL_ERROR); + result = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); } } return result; diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java index 11878376f5..c8135ad54b 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java @@ -25,19 +25,19 @@ import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.dao.utils.MapUtil; import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.*; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; -import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation; import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.IGroupOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -58,14 +58,14 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation private static final Logger log = Logger.getLogger(GroupOperation.class.getName()); - private final TitanDao titanDao; + private final JanusGraphDao janusGraphDao; private final TopologyTemplateOperation topologyTemplateOperation; private final PropertyOperation propertyOperation; private final GroupTypeOperation groupTypeOperation; private final ApplicationDataTypeCache dataTypeCache; - public GroupOperation(TitanDao titanDao, TopologyTemplateOperation topologyTemplateOperation, PropertyOperation propertyOperation, GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache dataTypeCache) { - this.titanDao = titanDao; + public GroupOperation(JanusGraphDao janusGraphDao, TopologyTemplateOperation topologyTemplateOperation, PropertyOperation propertyOperation, GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache dataTypeCache) { + this.janusGraphDao = janusGraphDao; this.topologyTemplateOperation = topologyTemplateOperation; this.propertyOperation = propertyOperation; this.groupTypeOperation = groupTypeOperation; @@ -83,17 +83,18 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation * @param groupUniqueId * @return */ - private Either, TitanOperationStatus> getGroupMembers(String groupUniqueId) { + private Either, JanusGraphOperationStatus> getGroupMembers(String groupUniqueId) { - Either, TitanOperationStatus> result = null; + Either, JanusGraphOperationStatus> result = null; - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER, NodeTypeEnum.ResourceInstance, ComponentInstanceData.class); if (childrenNodes.isRight()) { - TitanOperationStatus status = childrenNodes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childrenNodes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } result = Either.right(status); @@ -119,10 +120,11 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation private Either getGroupTypeOfGroup(String groupUniqueId) { - Either, StorageOperationStatus> groupTypeRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType, + Either, StorageOperationStatus> groupTypeRes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType, GroupTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (groupTypeRes.isRight()) { StorageOperationStatus status = groupTypeRes.right().value(); @@ -169,10 +171,11 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation Map uidToPropDefMap = groupTypeProperties.stream().collect(Collectors.toMap(PropertyDefinition::getUniqueId, Function.identity())); // Find all properties values on the group - Either>, StorageOperationStatus> propertyImplNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUid, GraphEdgeLabels.PROPERTY_VALUE, + Either>, StorageOperationStatus> propertyImplNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUid, GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (propertyImplNodes.isRight()) { StorageOperationStatus status = propertyImplNodes.right().value(); @@ -197,10 +200,11 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation String propertyValueUid = propertyValueData.getUniqueId(); String value = propertyValueData.getValue(); - Either, StorageOperationStatus> propertyDefRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL, + Either, StorageOperationStatus> propertyDefRes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL, NodeTypeEnum.Property, PropertyData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (propertyDefRes.isRight()) { StorageOperationStatus status = propertyDefRes.right().value(); if (status == StorageOperationStatus.NOT_FOUND) { @@ -262,9 +266,10 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation UniqueIdData artifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId); for (GroupDefinition groupDefinition : associatedGroups) { UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId()); - Either deleteRelation = titanGenericDao.deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF) + Either deleteRelation = janusGraphGenericDao + .deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (deleteRelation.isRight()) { StorageOperationStatus status = deleteRelation.right().value(); if (status == StorageOperationStatus.NOT_FOUND) { @@ -289,9 +294,10 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation Either result = null; - Either groupRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class) + Either groupRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (groupRes.isRight()) { StorageOperationStatus status = groupRes.right().value(); log.debug("Failed to retrieve group {} from graph. Status is {}", uniqueId, status); @@ -321,7 +327,7 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation if (!skipMembers) { Either, StorageOperationStatus> membersRes = getGroupMembers(uniqueId) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (membersRes.isRight()) { StorageOperationStatus status = membersRes.right().value(); if (status != StorageOperationStatus.OK) { @@ -351,7 +357,7 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation if (!skipArtifacts) { Either>, StorageOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (artifactsRes.isRight()) { StorageOperationStatus status = artifactsRes.right().value(); if (status != StorageOperationStatus.OK) { @@ -384,12 +390,13 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation @Override public boolean isGroupExist(String groupName, boolean inTransaction) { - Either, TitanOperationStatus> eitherGroup = null; + Either, JanusGraphOperationStatus> eitherGroup = null; try { Map properties = new HashMap<>(); properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName); - eitherGroup = titanGenericDao.getByCriteria(NodeTypeEnum.Group, properties, GroupData.class); + eitherGroup = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.Group, properties, GroupData.class); return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty(); } finally { @@ -401,10 +408,11 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation List groups = new ArrayList<>(); - Either>, StorageOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group, + Either>, StorageOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group, GroupData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (childrenNodes.isRight()) { StorageOperationStatus status = childrenNodes.right().value(); @@ -467,9 +475,10 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation for (GroupDefinition groupDefinition : associatedGroups) { UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId()); - Either deleteRelation = titanGenericDao.deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF) + Either deleteRelation = janusGraphGenericDao + .deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); log.trace("After dissociate group {} from artifact {}" , groupDefinition.getName(), oldArtifactId); if (deleteRelation.isRight()) { StorageOperationStatus status = deleteRelation.right().value(); @@ -479,9 +488,10 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation return status; } - Either createRelation = titanGenericDao.createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props) + Either createRelation = janusGraphGenericDao + .createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); log.trace("After associate group {} to artifact {}" , groupDefinition.getName(), newArtifact.getUniqueIdKey()); if (createRelation.isRight()) { StorageOperationStatus status = createRelation.right().value(); @@ -516,25 +526,26 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation if (result == null || result != StorageOperationStatus.OK) { log.debug("Going to execute rollback on graph."); BeEcompErrorManager.getInstance().logBeExecuteRollbackError("Rollback on graph"); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } } - private Either>, TitanOperationStatus> getGroupArtifactsPairs(String groupUniqueId) { + private Either>, JanusGraphOperationStatus> getGroupArtifactsPairs(String groupUniqueId) { - Either>, TitanOperationStatus> result = null; + Either>, JanusGraphOperationStatus> result = null; - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class); if (childrenNodes.isRight()) { - TitanOperationStatus status = childrenNodes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childrenNodes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } result = Either.right(status); @@ -565,12 +576,12 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation StorageOperationStatus result = null; String innerType = property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType(); - Either, TitanOperationStatus> allDataTypes = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll(); Either isValid = null; if (allDataTypes.isRight()) { - TitanOperationStatus status = allDataTypes.right().value(); + JanusGraphOperationStatus status = allDataTypes.right().value(); log.debug("Failed to fetch data types from cache. Status is {}. ", status); - result = DaoStatusConverter.convertTitanStatusToStorageStatus(status); + result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } if(result == null){ isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value()); @@ -591,9 +602,9 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation log.debug("#updateGroupProperties - updating the properties of group {} in component {}", groupId, containerComponent.getUniqueId()); Optional group = containerComponent.getGroupById(groupId); if (group.isPresent()){ - return titanDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse) + return janusGraphDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse) .either(containerVertex -> updateGroupProperties(containerVertex, group.get(), propertiesToUpdate), - DaoStatusConverter::convertTitanStatusToStorageStatus); + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } else { throw new StorageException(StorageOperationStatus.NOT_FOUND, groupId); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperation.java index 1817868255..430ba59e75 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperation.java @@ -21,7 +21,7 @@ package org.openecomp.sdc.be.model.operations.impl; import com.google.common.base.Strings; -import com.thinkaurelius.titan.graphdb.query.TitanPredicate; +import org.janusgraph.graphdb.query.JanusGraphPredicate; import fj.data.Either; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; @@ -30,11 +30,11 @@ import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.CapabilityDefinition; @@ -54,7 +54,7 @@ import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; -import static org.openecomp.sdc.be.dao.titan.TitanUtils.buildNotInPredicate; +import static org.openecomp.sdc.be.dao.janusgraph.JanusGraphUtils.buildNotInPredicate; @Component("group-type-operation") public class GroupTypeOperation implements IGroupTypeOperation { @@ -63,19 +63,19 @@ public class GroupTypeOperation implements IGroupTypeOperation { private static final String CREATE_FLOW_CONTEXT = "CreateGroupType"; private final PropertyOperation propertyOperation; - private final TitanGenericDao titanGenericDao; + private final JanusGraphGenericDao janusGraphGenericDao; private final CapabilityTypeOperation capabilityTypeOperation; private final CapabilityOperation capabilityOperation; private final DerivedFromOperation derivedFromOperation; private final OperationUtils operationUtils; - public GroupTypeOperation(TitanGenericDao titanGenericDao, + public GroupTypeOperation(JanusGraphGenericDao janusGraphGenericDao, PropertyOperation propertyOperation, CapabilityTypeOperation capabilityTypeOperation, CapabilityOperation capabilityOperation, DerivedFromOperation derivedFromOperation, OperationUtils operationUtils) { - this.titanGenericDao = titanGenericDao; + this.janusGraphGenericDao = janusGraphGenericDao; this.propertyOperation = propertyOperation; this.capabilityTypeOperation = capabilityTypeOperation; this.capabilityOperation = capabilityOperation; @@ -101,11 +101,11 @@ public class GroupTypeOperation implements IGroupTypeOperation { try { - Either eitherStatus = addGroupTypeToGraph(groupTypeDefinition); + Either eitherStatus = addGroupTypeToGraph(groupTypeDefinition); if (eitherStatus.isRight()) { BeEcompErrorManager.getInstance().logBeFailedCreateNodeError(CREATE_FLOW_CONTEXT, groupTypeDefinition.getType(), eitherStatus.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); } else { result = getGroupType(eitherStatus.left().value().getUniqueId(), inTransaction); @@ -114,7 +114,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { return result; } finally { - titanGenericDao.handleTransactionCommitRollback(inTransaction, result); + janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result); } } @@ -127,16 +127,17 @@ public class GroupTypeOperation implements IGroupTypeOperation { public Either validateUpdateProperties(GroupTypeDefinition groupTypeDefinition) { - TitanOperationStatus error = null; + JanusGraphOperationStatus error = null; if (CollectionUtils.isNotEmpty(groupTypeDefinition.getProperties()) && !Strings.isNullOrEmpty(groupTypeDefinition.getDerivedFrom())) { - Either, TitanOperationStatus> allPropertiesRes = + Either, JanusGraphOperationStatus> allPropertiesRes = getAllGroupTypePropertiesFromAllDerivedFrom(groupTypeDefinition.getDerivedFrom()); - if (allPropertiesRes.isRight() && !allPropertiesRes.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + if (allPropertiesRes.isRight() && !allPropertiesRes.right().value().equals( + JanusGraphOperationStatus.NOT_FOUND)) { error = allPropertiesRes.right().value(); log.debug("Couldn't fetch derived from property nodes for group type {}, error: {}", groupTypeDefinition.getType(), error); } if (error == null && !allPropertiesRes.left().value().isEmpty()) { - Either, TitanOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(), + Either, JanusGraphOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(), groupTypeDefinition.getProperties()); if (validatePropertiesRes.isRight()) { error = validatePropertiesRes.right().value(); @@ -146,11 +147,12 @@ public class GroupTypeOperation implements IGroupTypeOperation { if (error == null) { return Either.left(groupTypeDefinition); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); } - private Either, TitanOperationStatus> getAllGroupTypePropertiesFromAllDerivedFrom(String firstParentType) { - return titanGenericDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), firstParentType, GroupTypeData.class) + private Either, JanusGraphOperationStatus> getAllGroupTypePropertiesFromAllDerivedFrom(String firstParentType) { + return janusGraphGenericDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), firstParentType, GroupTypeData.class) .left() .bind(parentGroup -> propertyOperation.getAllTypePropertiesFromAllDerivedFrom(parentGroup.getUniqueId(), NodeTypeEnum.GroupType, GroupTypeData.class)); } @@ -185,8 +187,8 @@ public class GroupTypeOperation implements IGroupTypeOperation { } } - TitanOperationStatus createCapResult = createCapabilities(new GroupTypeData(groupTypeDef), newGroupTypeCapabilities); - return DaoStatusConverter.convertTitanStatusToStorageStatus(createCapResult); + JanusGraphOperationStatus createCapResult = createCapabilities(new GroupTypeData(groupTypeDef), newGroupTypeCapabilities); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createCapResult); } /** @@ -239,9 +241,9 @@ public class GroupTypeOperation implements IGroupTypeOperation { .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue) ): null; } - private TitanOperationStatus createCapabilities(GroupTypeData groupTypeData, Map groupCapabilities) { + private JanusGraphOperationStatus createCapabilities(GroupTypeData groupTypeData, Map groupCapabilities) { if (MapUtils.isEmpty(groupCapabilities)) { - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } return groupCapabilities.values().stream() @@ -249,11 +251,11 @@ public class GroupTypeOperation implements IGroupTypeOperation { .filter(Either::isRight) .findFirst() .map(either -> either.right().value()) - .orElse(TitanOperationStatus.OK); + .orElse(JanusGraphOperationStatus.OK); } - private Either createCapability(GroupTypeData groupTypeData, CapabilityDefinition capabilityDef) { - Either eitherCapData = capabilityTypeOperation.getCapabilityTypeByType(capabilityDef.getType()); + private Either createCapability(GroupTypeData groupTypeData, CapabilityDefinition capabilityDef) { + Either eitherCapData = capabilityTypeOperation.getCapabilityTypeByType(capabilityDef.getType()); return eitherCapData .left() .map(CapabilityTypeData::new) @@ -270,15 +272,15 @@ public class GroupTypeOperation implements IGroupTypeOperation { * @return */ private Either, StorageOperationStatus> getCapablities(String groupTypeId) { - Either>, TitanOperationStatus> groupCapabilitiesOnGraph = - titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), groupTypeId, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class, true); + Either>, JanusGraphOperationStatus> groupCapabilitiesOnGraph = + janusGraphGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), groupTypeId, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class, true); if (groupCapabilitiesOnGraph.isRight()) { - TitanOperationStatus capabilityStatus = groupCapabilitiesOnGraph.right().value(); - if (capabilityStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus capabilityStatus = groupCapabilitiesOnGraph.right().value(); + if (capabilityStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(Collections.emptyList()); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(capabilityStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(capabilityStatus)); } List> groupCapabilites = groupCapabilitiesOnGraph.left().value(); @@ -286,26 +288,27 @@ public class GroupTypeOperation implements IGroupTypeOperation { return capabilityOperation.getCapabilitiesWithProps(groupCapabilites) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } private void fillCapabilityName(ImmutablePair pair) { pair.getLeft().getCapabilityDataDefinition().setName((String)pair.getRight().getProperties().get(GraphEdgePropertiesDictionary.NAME.getProperty())); } - private Either connectToCapability(GroupTypeData groupTypeData, CapabilityData capabilityData, String capabilityName) { + private Either connectToCapability(GroupTypeData groupTypeData, CapabilityData capabilityData, String capabilityName) { Map properties = new HashMap<>(); properties.put(GraphEdgePropertiesDictionary.NAME.getProperty(), capabilityName); - return titanGenericDao.createRelation(groupTypeData, capabilityData, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, properties); + return janusGraphGenericDao.createRelation(groupTypeData, capabilityData, GraphEdgeLabels.GROUP_TYPE_CAPABILITY, properties); } public List getAllGroupTypes(Set excludedGroupTypes) { - Map> predicateCriteria = buildNotInPredicate(GraphPropertiesDictionary.TYPE.getProperty(), excludedGroupTypes); - List groupTypes = titanGenericDao.getByCriteriaWithPredicate(NodeTypeEnum.GroupType, predicateCriteria, GroupTypeData.class) + Map> predicateCriteria = buildNotInPredicate(GraphPropertiesDictionary.TYPE.getProperty(), excludedGroupTypes); + List groupTypes = janusGraphGenericDao + .getByCriteriaWithPredicate(NodeTypeEnum.GroupType, predicateCriteria, GroupTypeData.class) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); return convertGroupTypesToDefinition(groupTypes); } @@ -319,9 +322,10 @@ public class GroupTypeOperation implements IGroupTypeOperation { public Either getGroupTypeByUid(String uniqueId) { log.debug("#getGroupTypeByUid - fetching group type with id {}", uniqueId); - return titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), uniqueId, GroupTypeData.class) + return janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), uniqueId, GroupTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(groupType -> buildGroupTypeDefinition(uniqueId, groupType)); } @@ -346,7 +350,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { return result; } finally { - titanGenericDao.handleTransactionCommitRollback(inTransaction, result); + janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result); } } @@ -375,9 +379,10 @@ public class GroupTypeOperation implements IGroupTypeOperation { return result; } - Either, StorageOperationStatus> groupTypeEither = titanGenericDao.getByCriteria(NodeTypeEnum.GroupType, properties, GroupTypeData.class) + Either, StorageOperationStatus> groupTypeEither = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.GroupType, properties, GroupTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); if (groupTypeEither.isRight()) { result = Either.right(groupTypeEither.right().value()); } else { @@ -391,7 +396,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { return result; } finally { - titanGenericDao.handleTransactionCommitRollback(inTransaction, result); + janusGraphGenericDao.handleTransactionCommitRollback(inTransaction, result); } } @@ -432,11 +437,11 @@ public class GroupTypeOperation implements IGroupTypeOperation { .bind(propsMap -> fillDerivedFromProperties(groupType, derivedFromNode, new ArrayList<>(propsMap.values()))); } - Either, StorageOperationStatus> handleGroupTypeHasNoProperties(TitanOperationStatus err) { - if (err == TitanOperationStatus.NOT_FOUND) { + Either, StorageOperationStatus> handleGroupTypeHasNoProperties(JanusGraphOperationStatus err) { + if (err == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(new HashMap<>()); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(err)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(err)); } private Either, StorageOperationStatus> fillDerivedFromProperties(GroupTypeDefinition groupType, GroupTypeData derivedFromNode, List groupTypeDirectProperties) { @@ -493,7 +498,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { * @param groupTypeDefinition * @return */ - private Either addGroupTypeToGraph(GroupTypeDefinition groupTypeDefinition) { + private Either addGroupTypeToGraph(GroupTypeDefinition groupTypeDefinition) { log.debug("Got group type {}", groupTypeDefinition); @@ -503,18 +508,19 @@ public class GroupTypeOperation implements IGroupTypeOperation { log.debug("Before adding group type to graph. groupTypeData = {}", groupTypeData); - Either createGTResult = titanGenericDao.createNode(groupTypeData, GroupTypeData.class); + Either createGTResult = janusGraphGenericDao + .createNode(groupTypeData, GroupTypeData.class); log.debug("After adding group type to graph. status is = {}", createGTResult); if (createGTResult.isRight()) { - TitanOperationStatus operationStatus = createGTResult.right().value(); + JanusGraphOperationStatus operationStatus = createGTResult.right().value(); log.error("Failed to add group type {} to graph. status is {}", groupTypeDefinition.getType(), operationStatus); return Either.right(operationStatus); } GroupTypeData resultCTD = createGTResult.left().value(); List properties = groupTypeDefinition.getProperties(); - Either, TitanOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.GroupType, properties); + Either, JanusGraphOperationStatus> addPropertiesToCapablityType = propertyOperation.addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.GroupType, properties); if (addPropertiesToCapablityType.isRight()) { log.error("Failed add properties {} to capability {}", properties, groupTypeDefinition.getType()); return Either.right(addPropertiesToCapablityType.right().value()); @@ -522,7 +528,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { String derivedFrom = groupTypeDefinition.getDerivedFrom(); if (derivedFrom != null) { - Either createRelation = connectToDerivedFrom(ctUniqueId, derivedFrom); + Either createRelation = connectToDerivedFrom(ctUniqueId, derivedFrom); if (createRelation.isRight()) { return Either.right(createRelation.right().value()); } @@ -530,8 +536,8 @@ public class GroupTypeOperation implements IGroupTypeOperation { Map groupCapTypes = groupTypeDefinition.getCapabilities(); if (!MapUtils.isEmpty(groupCapTypes)) { - TitanOperationStatus status = createCapabilities(groupTypeData, groupCapTypes); - if (status != TitanOperationStatus.OK) { + JanusGraphOperationStatus status = createCapabilities(groupTypeData, groupCapTypes); + if (status != JanusGraphOperationStatus.OK) { return Either.right(status); } } @@ -541,21 +547,23 @@ public class GroupTypeOperation implements IGroupTypeOperation { } - private Either connectToDerivedFrom(String ctUniqueId, String derivedFrom) { + private Either connectToDerivedFrom(String ctUniqueId, String derivedFrom) { log.debug("Before creating relation between Group Type with id {} to its parent {}", ctUniqueId, derivedFrom); - Either derivedFromGroupTypeResult = - titanGenericDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), derivedFrom, GroupTypeData.class); + Either derivedFromGroupTypeResult = + janusGraphGenericDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), derivedFrom, GroupTypeData.class); if (derivedFromGroupTypeResult.isLeft()) { UniqueIdData from = new UniqueIdData(NodeTypeEnum.GroupType, ctUniqueId); GroupTypeData to = derivedFromGroupTypeResult.left().value(); - Either createRelation = titanGenericDao.createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null); + Either createRelation = janusGraphGenericDao + .createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null); log.debug("After create relation between Group Type with id {} to its parent {}, status is {}.", ctUniqueId, derivedFrom, createRelation); return createRelation; } else { - TitanOperationStatus status = derivedFromGroupTypeResult.right().value(); + JanusGraphOperationStatus status = derivedFromGroupTypeResult.right().value(); log.debug("Failed to found parent Group Type {}, stauts is {}.", derivedFrom, status); return Either.right(status); } @@ -579,23 +587,29 @@ public class GroupTypeOperation implements IGroupTypeOperation { public Either isCapabilityTypeDerivedFrom(String childCandidateType, String parentCandidateType) { Map propertiesToMatch = new HashMap<>(); propertiesToMatch.put(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), childCandidateType); - Either, TitanOperationStatus> getResponse = titanGenericDao.getByCriteria(NodeTypeEnum.CapabilityType, propertiesToMatch, CapabilityTypeData.class); + Either, JanusGraphOperationStatus> getResponse = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.CapabilityType, propertiesToMatch, CapabilityTypeData.class); if (getResponse.isRight()) { - TitanOperationStatus titanOperationStatus = getResponse.right().value(); - log.debug("Couldn't fetch capability type {}, error: {}", childCandidateType, titanOperationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value(); + log.debug("Couldn't fetch capability type {}, error: {}", childCandidateType, + janusGraphOperationStatus); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } String childUniqueId = getResponse.left().value().get(0).getUniqueId(); Set travelledTypes = new HashSet<>(); do { travelledTypes.add(childUniqueId); - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), childUniqueId, GraphEdgeLabels.DERIVED_FROM, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), childUniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.CapabilityType, CapabilityTypeData.class); if (childrenNodes.isRight()) { - if (childrenNodes.right().value() != TitanOperationStatus.NOT_FOUND) { - TitanOperationStatus titanOperationStatus = getResponse.right().value(); - log.debug("Couldn't fetch derived from node for capability type {}, error: {}", childCandidateType, titanOperationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + if (childrenNodes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = getResponse.right().value(); + log.debug("Couldn't fetch derived from node for capability type {}, error: {}", childCandidateType, + janusGraphOperationStatus); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } else { log.debug("Derived from node is not found for type {} - this is OK for root capability.", childCandidateType); return Either.left(false); @@ -627,9 +641,9 @@ public class GroupTypeOperation implements IGroupTypeOperation { private Either updateGroupTypeOnGraph(GroupTypeDefinition updatedGroupType, GroupTypeDefinition currGroupType) { updateGroupTypeData(updatedGroupType, currGroupType); - return titanGenericDao.updateNode(new GroupTypeData(updatedGroupType), GroupTypeData.class) + return janusGraphGenericDao.updateNode(new GroupTypeData(updatedGroupType), GroupTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(updatedNode -> updateGroupProperties(updatedGroupType.getUniqueId(), updatedGroupType.getProperties())) .left() @@ -649,7 +663,7 @@ public class GroupTypeOperation implements IGroupTypeOperation { .collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())): null; return propertyOperation.mergePropertiesAssociatedToNode(NodeTypeEnum.GroupType, groupId, mapProperties) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java index 6d050afb2c..823c33a311 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java @@ -25,10 +25,10 @@ import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Edge; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.HeatParameterDefinition; import org.openecomp.sdc.be.model.heat.HeatParameterType; @@ -55,27 +55,28 @@ public class HeatParametersOperation implements IHeatParametersOperation { private static final Logger log = Logger.getLogger(HeatParametersOperation.class.getName()); @javax.annotation.Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; - public TitanGenericDao getTitanGenericDao() { - return titanGenericDao; + public JanusGraphGenericDao getJanusGraphGenericDao() { + return janusGraphGenericDao; } - public void setTitanGenericDao(TitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } public StorageOperationStatus getHeatParametersOfNode(NodeTypeEnum nodeType, String uniqueId, List properties) { - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.HEAT_PARAMETER, NodeTypeEnum.HeatParameter, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.HEAT_PARAMETER, NodeTypeEnum.HeatParameter, HeatParameterData.class); if (childrenNodes.isRight()) { - TitanOperationStatus status = childrenNodes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childrenNodes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } List> values = childrenNodes.left().value(); @@ -103,15 +104,16 @@ public class HeatParametersOperation implements IHeatParametersOperation { public StorageOperationStatus getParametersValueNodes(NodeTypeEnum parentNodeType, String parentUniqueId, List heatValues) { - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentUniqueId, GraphEdgeLabels.PARAMETER_VALUE, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentUniqueId, GraphEdgeLabels.PARAMETER_VALUE, NodeTypeEnum.HeatParameterValue, HeatParameterValueData.class); if (childrenNodes.isRight()) { - TitanOperationStatus status = childrenNodes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = childrenNodes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } List> values = childrenNodes.left().value(); @@ -144,14 +146,14 @@ public class HeatParametersOperation implements IHeatParametersOperation { for (HeatParameterDefinition propertyDefinition : heatParams) { String propertyUid = propertyDefinition.getUniqueId(); - Either deletePropertyRes = deleteHeatParameterFromGraph(propertyUid); + Either deletePropertyRes = deleteHeatParameterFromGraph(propertyUid); if (deletePropertyRes.isRight()) { log.error("Failed to delete heat parameter with id {}", propertyUid); - TitanOperationStatus status = deletePropertyRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = deletePropertyRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } } @@ -173,14 +175,14 @@ public class HeatParametersOperation implements IHeatParametersOperation { for (HeatParameterValueData propertyDefinition : heatValues) { String propertyUid = (String) propertyDefinition.getUniqueId(); - Either deletePropertyRes = deleteHeatParameterValueFromGraph(propertyUid); + Either deletePropertyRes = deleteHeatParameterValueFromGraph(propertyUid); if (deletePropertyRes.isRight()) { log.error("Failed to delete heat parameter value with id {}", propertyUid); - TitanOperationStatus status = deletePropertyRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = deletePropertyRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - return DaoStatusConverter.convertTitanStatusToStorageStatus(status); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status); } } @@ -189,14 +191,15 @@ public class HeatParametersOperation implements IHeatParametersOperation { return StorageOperationStatus.OK; } - private Either deleteHeatParameterFromGraph(String propertyId) { + private Either deleteHeatParameterFromGraph(String propertyId) { log.debug("Before deleting heat parameter from graph {}" , propertyId); - return titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameter), propertyId, HeatParameterData.class); + return janusGraphGenericDao + .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameter), propertyId, HeatParameterData.class); } - private Either deleteHeatParameterValueFromGraph(String propertyId) { + private Either deleteHeatParameterValueFromGraph(String propertyId) { log.debug("Before deleting heat parameter from graph {}" , propertyId); - return titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameterValue), propertyId, HeatParameterValueData.class); + return janusGraphGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameterValue), propertyId, HeatParameterValueData.class); } @Override @@ -207,10 +210,10 @@ public class HeatParametersOperation implements IHeatParametersOperation { String propertyName = propertyDefinition.getName(); - Either addPropertyToGraph = addPropertyToGraph(propertyName, propertyDefinition, parentId, nodeType); + Either addPropertyToGraph = addPropertyToGraph(propertyName, propertyDefinition, parentId, nodeType); if (addPropertyToGraph.isRight()) { - return DaoStatusConverter.convertTitanStatusToStorageStatus(addPropertyToGraph.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertyToGraph.right().value()); } } } @@ -228,17 +231,18 @@ public class HeatParametersOperation implements IHeatParametersOperation { for (HeatParameterDefinition property : properties) { HeatParameterData heatParameterData = new HeatParameterData(property); - Either updateNode = titanGenericDao.updateNode(heatParameterData, HeatParameterData.class); + Either updateNode = janusGraphGenericDao + .updateNode(heatParameterData, HeatParameterData.class); if (updateNode.isRight()) { log.debug("failed to update heat parameter in graph. id = {}", property.getUniqueId()); - return DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value()); } } return StorageOperationStatus.OK; } - public Either addPropertyToGraph(String propertyName, HeatParameterDefinition propertyDefinition, String parentId, NodeTypeEnum nodeType) { + public Either addPropertyToGraph(String propertyName, HeatParameterDefinition propertyDefinition, String parentId, NodeTypeEnum nodeType) { UniqueIdData parentNode = new UniqueIdData(nodeType, parentId); @@ -246,19 +250,21 @@ public class HeatParametersOperation implements IHeatParametersOperation { HeatParameterData propertyData = new HeatParameterData(propertyDefinition); log.debug("Before adding property to graph {}" , propertyData); - Either createNodeResult = titanGenericDao.createNode(propertyData, HeatParameterData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(propertyData, HeatParameterData.class); log.debug("After adding property to graph {}" , propertyData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add property {} to graph. status is {}", propertyName, operationStatus); return Either.right(operationStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), propertyName); - Either createRelResult = titanGenericDao.createRelation(parentNode, propertyData, GraphEdgeLabels.HEAT_PARAMETER, props); + Either createRelResult = janusGraphGenericDao + .createRelation(parentNode, propertyData, GraphEdgeLabels.HEAT_PARAMETER, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate {} {} to heat parameter {} in graph. status is {}", nodeType.getName(), parentId, propertyName, operationStatus); return Either.right(operationStatus); } @@ -371,7 +377,8 @@ public class HeatParametersOperation implements IHeatParametersOperation { @Override public Either updateHeatParameterValue(HeatParameterDefinition heatParam, String artifactId, String resourceInstanceId, String artifactLabel) { String heatEnvId = UniqueIdBuilder.buildHeatParameterValueUniqueId(resourceInstanceId, artifactLabel, heatParam.getName()); - Either getNode = titanGenericDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, HeatParameterValueData.class); + Either getNode = janusGraphGenericDao + .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, HeatParameterValueData.class); if (getNode.isRight() || getNode.left().value() == null) { if (heatParam.getCurrentValue() == null || (heatParam.getDefaultValue() != null && heatParam.getCurrentValue().equals(heatParam.getDefaultValue()))) { log.debug("Updated heat parameter value equals default value. No need to create heat parameter value for heat parameter {}", heatParam.getUniqueId()); @@ -388,15 +395,17 @@ public class HeatParametersOperation implements IHeatParametersOperation { HeatParameterValueData heatParameterValue = new HeatParameterValueData(); heatParameterValue.setUniqueId(heatParam.getUniqueId()); if (heatParam.getCurrentValue() == null || (heatParam.getDefaultValue() != null && heatParam.getCurrentValue().equals(heatParam.getDefaultValue()))) { - Either deleteParameterValueIncomingRelation = titanGenericDao.deleteIncomingRelationByCriteria(heatParameterValue, GraphEdgeLabels.PARAMETER_VALUE, null); + Either deleteParameterValueIncomingRelation = janusGraphGenericDao + .deleteIncomingRelationByCriteria(heatParameterValue, GraphEdgeLabels.PARAMETER_VALUE, null); if (deleteParameterValueIncomingRelation.isRight()) { log.debug("Failed to delete heat parameter value incoming relation on graph. id = {}", heatParameterValue.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteParameterValueIncomingRelation.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteParameterValueIncomingRelation.right().value())); } - Either getOutgoingRelation = titanGenericDao.getOutgoingEdgeByCriteria(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) heatParameterValue.getUniqueId(), GraphEdgeLabels.PARAMETER_IMPL, null); + Either getOutgoingRelation = janusGraphGenericDao + .getOutgoingEdgeByCriteria(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) heatParameterValue.getUniqueId(), GraphEdgeLabels.PARAMETER_IMPL, null); if (getOutgoingRelation.isRight()) { log.debug("Failed to get heat parameter value outgoing relation from graph. id = {}", heatParameterValue.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getOutgoingRelation.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getOutgoingRelation.right().value())); } Edge edge = getOutgoingRelation.left().value(); if (edge == null) { @@ -405,33 +414,35 @@ public class HeatParametersOperation implements IHeatParametersOperation { } edge.remove(); - Either deleteNode = titanGenericDao.deleteNode(heatParameterValue, HeatParameterValueData.class); + Either deleteNode = janusGraphGenericDao + .deleteNode(heatParameterValue, HeatParameterValueData.class); if (deleteNode.isRight()) { log.debug("Failed to delete heat parameter value on graph. id = {}", heatParameterValue.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteNode.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteNode.right().value())); } return Either.left(deleteNode.left().value()); } heatParameterValue.setValue(heatParam.getCurrentValue()); - Either updateNode = titanGenericDao.updateNode(heatParameterValue, HeatParameterValueData.class); + Either updateNode = janusGraphGenericDao + .updateNode(heatParameterValue, HeatParameterValueData.class); if (updateNode.isRight()) { log.debug("Failed to update heat parameter value in graph. id = {}", heatParameterValue.getUniqueId()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value())); } return Either.left(updateNode.left().value()); } public Either createHeatParameterValue(HeatParameterDefinition heatParam, String artifactId, String resourceInstanceId, String artifactLabel) { - Either addHeatValueToGraph = addHeatValueToGraph(heatParam, artifactLabel, artifactId, resourceInstanceId); + Either addHeatValueToGraph = addHeatValueToGraph(heatParam, artifactLabel, artifactId, resourceInstanceId); if (addHeatValueToGraph.isRight()) { log.debug("Failed to create heat parameters value on graph for artifact {}", artifactId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(addHeatValueToGraph.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addHeatValueToGraph.right().value())); } return Either.left(addHeatValueToGraph.left().value()); } - public Either addHeatValueToGraph(HeatParameterDefinition heatParameter, String artifactLabel, String artifactId, String resourceInstanceId) { + public Either addHeatValueToGraph(HeatParameterDefinition heatParameter, String artifactLabel, String artifactId, String resourceInstanceId) { UniqueIdData heatEnvNode = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId); HeatParameterValueData heatValueData = new HeatParameterValueData(); @@ -439,26 +450,29 @@ public class HeatParametersOperation implements IHeatParametersOperation { heatValueData.setValue(heatParameter.getCurrentValue()); log.debug("Before adding property to graph {}", heatValueData); - Either createNodeResult = titanGenericDao.createNode(heatValueData, HeatParameterValueData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(heatValueData, HeatParameterValueData.class); log.debug("After adding property to graph {}", heatValueData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add heat value {} to graph. status is {}", heatValueData.getUniqueId(), operationStatus); return Either.right(operationStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), heatParameter.getName()); - Either createRelResult = titanGenericDao.createRelation(heatEnvNode, heatValueData, GraphEdgeLabels.PARAMETER_VALUE, props); + Either createRelResult = janusGraphGenericDao + .createRelation(heatEnvNode, heatValueData, GraphEdgeLabels.PARAMETER_VALUE, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate heat value {} to heat env artifact {} in graph. status is {}", heatValueData.getUniqueId(), artifactId, operationStatus); return Either.right(operationStatus); } UniqueIdData heatParameterNode = new UniqueIdData(NodeTypeEnum.HeatParameter, heatParameter.getUniqueId()); - Either createRel2Result = titanGenericDao.createRelation(heatValueData, heatParameterNode, GraphEdgeLabels.PARAMETER_IMPL, null); + Either createRel2Result = janusGraphGenericDao + .createRelation(heatValueData, heatParameterNode, GraphEdgeLabels.PARAMETER_IMPL, null); if (createRel2Result.isRight()) { - TitanOperationStatus operationStatus = createRel2Result.right().value(); + JanusGraphOperationStatus operationStatus = createRel2Result.right().value(); log.error("Failed to associate heat value {} to heat parameter {} in graph. status is {}", heatValueData.getUniqueId(), heatParameter.getName(), operationStatus); return Either.right(operationStatus); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InputsOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InputsOperation.java index 9c5445a8c2..b9a4c7f66f 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InputsOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InputsOperation.java @@ -26,10 +26,10 @@ import org.apache.tinkerpop.gremlin.structure.Edge; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ComponentInstanceInput; import org.openecomp.sdc.be.model.operations.api.IInputsOperation; @@ -48,20 +48,22 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati @Autowired PropertyOperation propertyOperation; - public TitanOperationStatus findAllResourceElementsDefinitionRecursively(String resourceId, List elements, NodeElementFetcher singleNodeFetcher) { + public JanusGraphOperationStatus findAllResourceElementsDefinitionRecursively(String resourceId, List elements, NodeElementFetcher singleNodeFetcher) { log.trace("Going to fetch elements under resource {}" , resourceId); - TitanOperationStatus resourceAttributesStatus = singleNodeFetcher.findAllNodeElements(resourceId, elements); + JanusGraphOperationStatus + resourceAttributesStatus = singleNodeFetcher.findAllNodeElements(resourceId, elements); - if (resourceAttributesStatus != TitanOperationStatus.OK) { + if (resourceAttributesStatus != JanusGraphOperationStatus.OK) { return resourceAttributesStatus; } - Either, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); + Either, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); if (parentNodes.isRight()) { - TitanOperationStatus parentNodesStatus = parentNodes.right().value(); - if (parentNodesStatus != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value(); + if (parentNodesStatus != JanusGraphOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance().logInternalFlowError("findAllResourceElementsDefinitionRecursively", "Failed to find parent elements of resource " + resourceId + ". status is " + parentNodesStatus, ErrorSeverity.ERROR); return parentNodesStatus; } @@ -70,26 +72,26 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati if (parentNodes.isLeft()) { ImmutablePair parnetNodePair = parentNodes.left().value(); String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId(); - TitanOperationStatus addParentIntStatus = findAllResourceElementsDefinitionRecursively(parentUniqueId, elements, singleNodeFetcher); + JanusGraphOperationStatus addParentIntStatus = findAllResourceElementsDefinitionRecursively(parentUniqueId, elements, singleNodeFetcher); - if (addParentIntStatus != TitanOperationStatus.OK) { + if (addParentIntStatus != JanusGraphOperationStatus.OK) { BeEcompErrorManager.getInstance().logInternalFlowError("findAllResourceElementsDefinitionRecursively", "Failed to find all resource elements of resource " + parentUniqueId, ErrorSeverity.ERROR); return addParentIntStatus; } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } @Override - public ImmutablePair findInputValue(String resourceInstanceId, String propertyId) { + public ImmutablePair findInputValue(String resourceInstanceId, String propertyId) { log.debug("Going to check whether the property {} already added to resource instance {}", propertyId, resourceInstanceId); - Either, TitanOperationStatus> getAllRes = getAllInputsOfResourceInstanceOnlyInputDefId(resourceInstanceId); + Either, JanusGraphOperationStatus> getAllRes = getAllInputsOfResourceInstanceOnlyInputDefId(resourceInstanceId); if (getAllRes.isRight()) { - TitanOperationStatus status = getAllRes.right().value(); + JanusGraphOperationStatus status = getAllRes.right().value(); log.trace("After fetching all properties of resource instance {}. Status is {}" ,resourceInstanceId, status); return new ImmutablePair<>(status, null); } @@ -102,12 +104,12 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati log.trace("Go over property {} under resource instance {}. valueUniqueId = {}" ,propertyUniqueId, resourceInstanceId, valueUniqueUid); if (propertyId.equals(propertyUniqueId) && valueUniqueUid != null) { log.debug("The property {} already created under resource instance {}", propertyId, resourceInstanceId); - return new ImmutablePair<>(TitanOperationStatus.ALREADY_EXIST, valueUniqueUid); + return new ImmutablePair<>(JanusGraphOperationStatus.ALREADY_EXIST, valueUniqueUid); } } } - return new ImmutablePair<>(TitanOperationStatus.NOT_FOUND, null); + return new ImmutablePair<>(JanusGraphOperationStatus.NOT_FOUND, null); } /** @@ -116,34 +118,36 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati * @param resourceInstanceUid * @return */ - public Either, TitanOperationStatus> getAllInputsOfResourceInstanceOnlyInputDefId(String resourceInstanceUid) { + public Either, JanusGraphOperationStatus> getAllInputsOfResourceInstanceOnlyInputDefId(String resourceInstanceUid) { return getAllInputsOfResourceInstanceOnlyInputDefId(resourceInstanceUid, NodeTypeEnum.ResourceInstance); } - public Either, TitanOperationStatus> getAllInputsOfResourceInstanceOnlyInputDefId(String resourceInstanceUid, NodeTypeEnum instanceNodeType) { + public Either, JanusGraphOperationStatus> getAllInputsOfResourceInstanceOnlyInputDefId(String resourceInstanceUid, NodeTypeEnum instanceNodeType) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, ComponentInstanceData.class); + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, ComponentInstanceData.class); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } - Either>, TitanOperationStatus> propertyImplNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, GraphEdgeLabels.INPUT_VALUE, NodeTypeEnum.InputValue, InputValueData.class); + Either>, JanusGraphOperationStatus> propertyImplNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, GraphEdgeLabels.INPUT_VALUE, NodeTypeEnum.InputValue, InputValueData.class); if (propertyImplNodes.isRight()) { - TitanOperationStatus status = propertyImplNodes.right().value(); + JanusGraphOperationStatus status = propertyImplNodes.right().value(); return Either.right(status); } List> list = propertyImplNodes.left().value(); if (list == null || list.isEmpty()) { - return Either.right(TitanOperationStatus.NOT_FOUND); + return Either.right(JanusGraphOperationStatus.NOT_FOUND); } List result = new ArrayList<>(); @@ -155,7 +159,8 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati String propertyValueUid = propertyValueData.getUniqueId(); String value = propertyValueData.getValue(); - Either, TitanOperationStatus> inputNodes = titanGenericDao.getParentNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), propertyValueData.getUniqueId(), GraphEdgeLabels.GET_INPUT, NodeTypeEnum.Input, InputsData.class); + Either, JanusGraphOperationStatus> inputNodes = janusGraphGenericDao + .getParentNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), propertyValueData.getUniqueId(), GraphEdgeLabels.GET_INPUT, NodeTypeEnum.Input, InputsData.class); if (inputNodes.isRight()) { @@ -165,25 +170,28 @@ public class InputsOperation extends AbstractOperation implements IInputsOperati InputsData input = inputNodes.left().value().left; String inputId = input.getPropertyDataDefinition().getUniqueId(); - Either, TitanOperationStatus> propertyDefRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InputValue), propertyValueUid, GraphEdgeLabels.INPUT_IMPL, NodeTypeEnum.Property, PropertyData.class); + Either, JanusGraphOperationStatus> propertyDefRes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InputValue), propertyValueUid, GraphEdgeLabels.INPUT_IMPL, NodeTypeEnum.Property, PropertyData.class); if (propertyDefRes.isRight()) { - TitanOperationStatus status = propertyDefRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = propertyDefRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } ImmutablePair propertyDefPair = propertyDefRes.left().value(); PropertyData propertyData = propertyDefPair.left; - Either inputsEges = titanGenericDao.getIncomingEdgeByCriteria(propertyData, GraphEdgeLabels.INPUT, null); + Either inputsEges = janusGraphGenericDao + .getIncomingEdgeByCriteria(propertyData, GraphEdgeLabels.INPUT, null); if (inputsEges.isRight()) { - TitanOperationStatus status = inputsEges.right().value(); + JanusGraphOperationStatus status = inputsEges.right().value(); return Either.right(status); } Edge edge = inputsEges.left().value(); - String inputName = (String) titanGenericDao.getProperty(edge, GraphEdgePropertiesDictionary.NAME.getProperty()); + String inputName = (String) janusGraphGenericDao + .getProperty(edge, GraphEdgePropertiesDictionary.NAME.getProperty()); ComponentInstanceInput resourceInstanceProperty = new ComponentInstanceInput(propertyData.getPropertyDataDefinition(), inputId, value, propertyValueUid); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java index ab2eb0323d..b9e95c507f 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java @@ -24,10 +24,10 @@ import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -63,7 +63,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation private ArtifactOperation artifactOperation; @javax.annotation.Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; @Override public Either addInterfaceToResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean inTransaction) { @@ -72,27 +72,29 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } - private Either addOperationToGraph(InterfaceDefinition interf, String opName, Operation op, InterfaceData interfaceData) { + private Either addOperationToGraph(InterfaceDefinition interf, String opName, Operation op, InterfaceData interfaceData) { op.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId((String) interfaceData.getUniqueId(), opName)); OperationData operationData = new OperationData(op); log.debug("Before adding operation to graph {}", operationData); - Either createOpNodeResult = titanGenericDao.createNode(operationData, OperationData.class); + Either createOpNodeResult = janusGraphGenericDao + .createNode(operationData, OperationData.class); log.debug("After adding operation to graph {}", operationData); if (createOpNodeResult.isRight()) { - TitanOperationStatus opStatus = createOpNodeResult.right().value(); + JanusGraphOperationStatus opStatus = createOpNodeResult.right().value(); log.error("Failed to add operation {} to graph. status is {}", opName, opStatus); return Either.right(opStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), opName); - Either createRelResult = titanGenericDao.createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props); + Either createRelResult = janusGraphGenericDao + .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createOpNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createOpNodeResult.right().value(); log.error("Failed to associate operation {} to property {} in graph. status is {}", interfaceData.getUniqueId(), opName, operationStatus); return Either.right(operationStatus); @@ -118,7 +120,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } - private Either addInterfaceToGraph(InterfaceDefinition interfaceInfo, String interfaceName, String resourceId) { + private Either addInterfaceToGraph(InterfaceDefinition interfaceInfo, String interfaceName, String resourceId) { InterfaceData interfaceData = new InterfaceData(interfaceInfo); @@ -129,33 +131,36 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation interfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted)); - Either existInterface = titanGenericDao.getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class); + Either existInterface = janusGraphGenericDao + .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class); if (existInterface.isRight()) { return createInterfaceNodeAndRelation(interfaceNameSplitted, resourceId, interfaceData, resourceData); } else { log.debug("Interface {} already exist", interfaceData.getUniqueId()); - return Either.right(TitanOperationStatus.ALREADY_EXIST); + return Either.right(JanusGraphOperationStatus.ALREADY_EXIST); } } - private Either createInterfaceNodeAndRelation(String interfaceName, String resourceId, InterfaceData interfaceData, ResourceMetadataData resourceData) { + private Either createInterfaceNodeAndRelation(String interfaceName, String resourceId, InterfaceData interfaceData, ResourceMetadataData resourceData) { log.debug("Before adding interface to graph {}", interfaceData); - Either createNodeResult = titanGenericDao.createNode(interfaceData, InterfaceData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(interfaceData, InterfaceData.class); log.debug("After adding property to graph {}", interfaceData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add interface {} to graph. status is {}", interfaceName, operationStatus); return Either.right(operationStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), interfaceName); - Either createRelResult = titanGenericDao.createRelation(resourceData, interfaceData, GraphEdgeLabels.INTERFACE, props); + Either createRelResult = janusGraphGenericDao + .createRelation(resourceData, interfaceData, GraphEdgeLabels.INTERFACE, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to associate resource {} to property {} in graph. status is {}", resourceId, interfaceName, operationStatus); return Either.right(operationStatus); @@ -164,22 +169,24 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation return Either.left(createNodeResult.left().value()); } - private Either createOperationNodeAndRelation(String operationName, OperationData operationData, InterfaceData interfaceData) { + private Either createOperationNodeAndRelation(String operationName, OperationData operationData, InterfaceData interfaceData) { log.debug("Before adding operation to graph {}", operationData); - Either createNodeResult = titanGenericDao.createNode(operationData, OperationData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(operationData, OperationData.class); log.debug("After adding operation to graph {}", interfaceData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add interfoperationce {} to graph. status is {}", operationName, operationStatus); return Either.right(operationStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), operationName); - Either createRelResult = titanGenericDao.createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props); + Either createRelResult = janusGraphGenericDao + .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to associate operation {} to interface {} in graph. status is {}", operationName, interfaceData.getUniqueId(), operationStatus); return Either.right(operationStatus); @@ -205,15 +212,15 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation return result; } - TitanOperationStatus findInterfacesRes = TitanOperationStatus.GENERAL_ERROR; + JanusGraphOperationStatus findInterfacesRes = JanusGraphOperationStatus.GENERAL_ERROR; if (recursively) { findInterfacesRes = findAllInterfacesRecursively(resourceId, interfaces); } else { findInterfacesRes = findAllInterfacesNotRecursively(resourceId, interfaces); } - if (!findInterfacesRes.equals(TitanOperationStatus.OK)) { + if (!findInterfacesRes.equals(JanusGraphOperationStatus.OK)) { log.error("Failed to get all interfaces of resource {}. status is {}", resourceId, findInterfacesRes); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(findInterfacesRes)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findInterfacesRes)); return result; } result = Either.left(interfaces); @@ -222,23 +229,24 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } } - private TitanOperationStatus findAllInterfacesNotRecursively(String resourceId, Map interfaces) { + private JanusGraphOperationStatus findAllInterfacesNotRecursively(String resourceId, Map interfaces) { - Either>, TitanOperationStatus> interfaceNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.INTERFACE, + Either>, JanusGraphOperationStatus> interfaceNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class); if (interfaceNodes.isRight()) { - TitanOperationStatus status = interfaceNodes.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = interfaceNodes.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return status; } } else { @@ -246,15 +254,15 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation if (interfaceList != null) { for (ImmutablePair interfacePair : interfaceList) { String interfaceUniqueId = (String) interfacePair.getKey().getUniqueId(); - Either interfaceNameRes = getPropertyValueFromEdge(interfacePair.getValue(), GraphPropertiesDictionary.NAME); + Either interfaceNameRes = getPropertyValueFromEdge(interfacePair.getValue(), GraphPropertiesDictionary.NAME); if (interfaceNameRes.isRight()) { log.error("The requirement name is missing on the edge of requirement {}", interfaceUniqueId); return interfaceNameRes.right().value(); } String interfaceName = interfaceNameRes.left().value(); - Either interfaceDefRes = getNonRecursiveInterface(interfacePair.getKey()); + Either interfaceDefRes = getNonRecursiveInterface(interfacePair.getKey()); if (interfaceDefRes.isRight()) { - TitanOperationStatus status = interfaceDefRes.right().value(); + JanusGraphOperationStatus status = interfaceDefRes.right().value(); log.error("Failed to get interface actions of interface {}", interfaceUniqueId); return status; } @@ -271,24 +279,26 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - public TitanOperationStatus findAllInterfacesRecursively(String resourceId, Map interfaces) { + public JanusGraphOperationStatus findAllInterfacesRecursively(String resourceId, Map interfaces) { - TitanOperationStatus findAllInterfacesNotRecursively = findAllInterfacesNotRecursively(resourceId, interfaces); - if (!findAllInterfacesNotRecursively.equals(TitanOperationStatus.OK)) { + JanusGraphOperationStatus + findAllInterfacesNotRecursively = findAllInterfacesNotRecursively(resourceId, interfaces); + if (!findAllInterfacesNotRecursively.equals(JanusGraphOperationStatus.OK)) { log.error("failed to get interfaces for resource {}. status is {}", resourceId, findAllInterfacesNotRecursively); } - Either, TitanOperationStatus> parentNodes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, + Either, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); if (parentNodes.isRight()) { - TitanOperationStatus parentNodesStatus = parentNodes.right().value(); - if (parentNodesStatus == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value(); + if (parentNodesStatus == JanusGraphOperationStatus.NOT_FOUND) { log.debug("Finish to lookup for parnet interfaces"); - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } else { log.error("Failed to find parent interfaces of resource {}. status is {}", resourceId, parentNodesStatus); return parentNodesStatus; @@ -296,42 +306,44 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } ImmutablePair parnetNodePair = parentNodes.left().value(); String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId(); - TitanOperationStatus addParentIntStatus = findAllInterfacesRecursively(parentUniqueId, interfaces); + JanusGraphOperationStatus + addParentIntStatus = findAllInterfacesRecursively(parentUniqueId, interfaces); - if (addParentIntStatus != TitanOperationStatus.OK) { + if (addParentIntStatus != JanusGraphOperationStatus.OK) { log.error("Failed to fetch all interfaces of resource {}", parentUniqueId); return addParentIntStatus; } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - private Either getPropertyValueFromEdge(GraphEdge edge, GraphPropertiesDictionary property) { + private Either getPropertyValueFromEdge(GraphEdge edge, GraphPropertiesDictionary property) { Map edgeProps = edge.getProperties(); String interfaceName = null; if (edgeProps != null) { interfaceName = (String) edgeProps.get(property.getProperty()); if (interfaceName == null) { - return Either.right(TitanOperationStatus.INVALID_ELEMENT); + return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT); } } else { - return Either.right(TitanOperationStatus.INVALID_ELEMENT); + return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT); } return Either.left(interfaceName); } - private Either getNonRecursiveInterface(InterfaceData interfaceData) { + private Either getNonRecursiveInterface(InterfaceData interfaceData) { log.debug("Going to fetch the operations associate to interface {}", interfaceData.getUniqueId()); InterfaceDefinition interfaceDefinition = new InterfaceDefinition(interfaceData.getInterfaceDataDefinition()); String interfaceId = interfaceData.getUniqueId(); - Either>, TitanOperationStatus> operationsRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceId, GraphEdgeLabels.INTERFACE_OPERATION, + Either>, JanusGraphOperationStatus> operationsRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceId, GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (operationsRes.isRight()) { - TitanOperationStatus status = operationsRes.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = operationsRes.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return Either.right(status); } else { return Either.left(interfaceDefinition); @@ -342,7 +354,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation if (operationList != null && !operationList.isEmpty()) { for (ImmutablePair operationPair : operationList) { Operation operation = new Operation(operationPair.getKey().getOperationDataDefinition()); - Either operationNameRes = getPropertyValueFromEdge(operationPair.getValue(), GraphPropertiesDictionary.NAME); + Either operationNameRes = getPropertyValueFromEdge(operationPair.getValue(), GraphPropertiesDictionary.NAME); if (operationNameRes.isRight()) { log.error("The operation name is missing on the edge of operation {}", operationPair.getKey().getUniqueId()); return Either.right(operationNameRes.right().value()); @@ -401,7 +413,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation private Either updateOperationOnGraph(Operation operation, String resourceId, String interfaceName, String operationName) { - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class); if (childrenNodes.isRight()) { @@ -415,7 +428,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } private Either updateExistingOperation(String resourceId, Operation operation, String interfaceName, String operationName, - Either>, TitanOperationStatus> childrenNodes) { + Either>, JanusGraphOperationStatus> childrenNodes) { Operation newOperation = null; StorageOperationStatus storageOperationStatus = StorageOperationStatus.GENERAL_ERROR; @@ -426,11 +439,12 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation InterfaceData interfaceData = interfaceDataNode.getKey(); if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) { - Either>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(), + Either>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (operationRes.isRight()) { log.error("Failed to find operation {} on interface {}", operationName, interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value())); } else { List> operations = operationRes.left().value(); for (ImmutablePair operationPairEdge : operations) { @@ -439,7 +453,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation Map opEdgeProp = opEdge.getProperties(); if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) { ArtifactDefinition artifact = operation.getImplementationArtifact(); - Either, TitanOperationStatus> artifactRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) opData.getUniqueId(), GraphEdgeLabels.ARTIFACT_REF, + Either, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao + .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) opData.getUniqueId(), GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class); Either artStatus; if (artifactRes.isRight()) { @@ -448,7 +463,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation artStatus = artifactOperation.updateArifactOnResource(artifact, (String) operationPairEdge.getLeft().getUniqueId(), (String) artifactRes.left().value().getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true); } if (artStatus.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add artifact {} to interface {}", operationName, interfaceName); return Either.right(artStatus.right().value()); } else { @@ -461,18 +476,19 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } if (newOperation == null) { - Either parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName); + Either parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName); if (parentInterfaceStatus.isRight()) { log.debug("Interface {} not exist", interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentInterfaceStatus.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value())); } InterfaceData parentInterfaceData = parentInterfaceStatus.left().value(); - Either>, TitanOperationStatus> opRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) parentInterfaceData.getUniqueId(), + Either>, JanusGraphOperationStatus> opRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) parentInterfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (opRes.isRight()) { log.error("Failed to find operation {} on interface {}", operationName, interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value())); } else { List> parentOperations = opRes.left().value(); @@ -503,21 +519,21 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } private Either copyAndCreateNewOperation(Operation operation, String interfaceName, String operationName, Operation newOperation, InterfaceData interfaceData, - Either>, TitanOperationStatus> operationRes, OperationData opData) { + Either>, JanusGraphOperationStatus> operationRes, OperationData opData) { OperationDataDefinition opDataInfo = opData.getOperationDataDefinition(); OperationDataDefinition newOperationInfo = new OperationDataDefinition(opDataInfo); newOperationInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(interfaceData.getUniqueId(), operationName.toLowerCase())); OperationData newopData = new OperationData(newOperationInfo); - Either operationStatus = createOperationNodeAndRelation(operationName, newopData, interfaceData); + Either operationStatus = createOperationNodeAndRelation(operationName, newopData, interfaceData); if (operationStatus.isRight()) { log.error("Failed to create operation {} on interface {}", operationName, interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value())); } ArtifactDefinition artifact = operation.getImplementationArtifact(); if (artifact != null) { Either artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationStatus.left().value().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true); if (artStatus.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add artifact {} to interface {}", operationName, interfaceName); } else { newOperation = this.convertOperationDataToOperation(opData); @@ -532,10 +548,10 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation // Operation newOperation = null; ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(resourceId); - Either parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName); + Either parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName); if (parentInterfaceStatus.isRight()) { log.debug("Interface {} not exist", interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(parentInterfaceStatus.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value())); } InterfaceData interfaceData = parentInterfaceStatus.left().value(); @@ -546,25 +562,27 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation newInterfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted)); InterfaceData updatedInterfaceData = new InterfaceData(newInterfaceInfo); - Either createStatus = createInterfaceNodeAndRelation(interfaceName, resourceId, updatedInterfaceData, resourceData); + Either createStatus = createInterfaceNodeAndRelation(interfaceName, resourceId, updatedInterfaceData, resourceData); if (createStatus.isRight()) { log.debug("failed to create interface node {} on resource {}", interfaceName, resourceId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createStatus.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createStatus.right().value())); } InterfaceData newInterfaceNode = createStatus.left().value(); - Either createRelResult = titanGenericDao.createRelation(newInterfaceNode, interfaceData, GraphEdgeLabels.DERIVED_FROM, null); + Either createRelResult = janusGraphGenericDao + .createRelation(newInterfaceNode, interfaceData, GraphEdgeLabels.DERIVED_FROM, null); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createRelResult.right().value(); + JanusGraphOperationStatus operationStatus = createRelResult.right().value(); log.error("Failed to associate interface {} to interface {} in graph. status is {}", interfaceData.getUniqueId(), newInterfaceNode.getUniqueId(), operationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); } - Either>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceData.getUniqueId(), + Either>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (operationRes.isRight()) { log.error("Failed to find operation {} on interface {}", operationName, interfaceName); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationRes.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value())); } else { List> operations = operationRes.left().value(); @@ -585,9 +603,10 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation return Either.right(StorageOperationStatus.GENERAL_ERROR); } - private Either findInterfaceOnParentNode(String resourceId, String interfaceName) { + private Either findInterfaceOnParentNode(String resourceId, String interfaceName) { - Either, TitanOperationStatus> parentRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, + Either, JanusGraphOperationStatus> parentRes = janusGraphGenericDao + .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class); if (parentRes.isRight()) { log.debug("interface {} not found ", interfaceName); @@ -595,7 +614,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } ImmutablePair parenNode = parentRes.left().value(); - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), parenNode.getKey().getMetadataDataDefinition().getUniqueId(), + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), parenNode.getKey().getMetadataDataDefinition().getUniqueId(), GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class); if (childrenNodes.isRight()) { return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName); @@ -619,16 +639,16 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation @Override public Either createInterfaceOnResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean failIfExist, boolean inTransaction) { - Either status = addInterfaceToGraph(interf, interfaceName, resourceId); + Either status = addInterfaceToGraph(interf, interfaceName, resourceId); if (status.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add interface {} to resource {}", interfaceName, resourceId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value())); } else { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } InterfaceData interfaceData = status.left().value(); @@ -640,13 +660,13 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation for (String operationName : opNames) { Operation op = operations.get(operationName); - Either opStatus = addOperationToGraph(interf, operationName, op, interfaceData); + Either opStatus = addOperationToGraph(interf, operationName, op, interfaceData); if (status.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add operation {} to interface {}", operationName, interfaceName); } else if (status.isLeft()) { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } OperationData opData = opStatus.left().value(); Operation newOperation = this.convertOperationDataToOperation(opData); @@ -655,7 +675,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation if (art != null) { Either artRes = artifactOperation.addArifactToComponent(art, (String) opData.getUniqueId(), NodeTypeEnum.InterfaceOperation, failIfExist, true); if (artRes.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add artifact {} to interface {}", operationName, interfaceName); } else { newOperation.setImplementation(artRes.left().value()); @@ -675,16 +695,16 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation @Override public Either deleteInterfaceOperation(String resourceId, String interfaceName, String operationId, boolean inTransaction) { - Either status = removeOperationOnGraph(resourceId, interfaceName, operationId); + Either status = removeOperationOnGraph(resourceId, interfaceName, operationId); if (status.isRight()) { if (!inTransaction) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } log.error("Failed to delete operation {} of interface {} resource {}", operationId, interfaceName, resourceId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value())); } else { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } Operation opDefResult = status.left().value();// convertOperationDataToOperation(operationData); @@ -694,10 +714,11 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } - private Either removeOperationOnGraph(String resourceId, String interfaceName, String operationId) { + private Either removeOperationOnGraph(String resourceId, String interfaceName, String operationId) { log.debug("Before deleting operation from graph {}", operationId); - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class); if (childrenNodes.isRight()) { @@ -713,7 +734,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation String interfaceSplitedName = splitType(interfaceName); if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceSplitedName)) { - Either>, TitanOperationStatus> operationRes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(), + Either>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao + .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (operationRes.isRight()) { log.error("Failed to find operation {} on interface {}", operationId, interfaceName); @@ -726,7 +748,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation opData = operationPairEdge.getLeft(); if (opData.getUniqueId().equals(operationId)) { - Either, TitanOperationStatus> artifactRes = titanGenericDao.getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) operationPairEdge.getLeft().getUniqueId(), + Either, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao + .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) operationPairEdge.getLeft().getUniqueId(), GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class); Either arStatus = null; if (artifactRes.isLeft()) { @@ -734,13 +757,14 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation arStatus = artifactOperation.removeArifactFromResource((String) operationPairEdge.getLeft().getUniqueId(), (String) arData.getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true); if (arStatus.isRight()) { log.debug("failed to delete artifact {}", arData.getUniqueId()); - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } } - Either deleteOpStatus = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), opData.getUniqueId(), OperationData.class); + Either deleteOpStatus = janusGraphGenericDao + .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), opData.getUniqueId(), OperationData.class); if (deleteOpStatus.isRight()) { log.debug("failed to delete operation {}", opData.getUniqueId()); - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } opData = deleteOpStatus.left().value(); Operation operation = new Operation(opData.getOperationDataDefinition()); @@ -748,10 +772,11 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation operation.setImplementation(arStatus.left().value()); } if (operations.size() <= 1) { - Either deleteInterfaceStatus = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceDataNode.left.getUniqueId(), InterfaceData.class); + Either deleteInterfaceStatus = janusGraphGenericDao + .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceDataNode.left.getUniqueId(), InterfaceData.class); if (deleteInterfaceStatus.isRight()) { log.debug("failed to delete interface {}", interfaceDataNode.left.getUniqueId()); - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } } @@ -764,7 +789,7 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } log.debug("Not found operation {}", interfaceName); - return Either.right(TitanOperationStatus.INVALID_ID); + return Either.right(JanusGraphOperationStatus.INVALID_ID); } private String splitType(String interfaceName) { @@ -783,10 +808,10 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation /** * FOR TEST ONLY * - * @param titanGenericDao + * @param janusGraphGenericDao */ - public void setTitanGenericDao(TitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } public void setArtifactOperation(ArtifactOperation artifactOperation) { @@ -801,7 +826,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation InterfaceData interfaceData = new InterfaceData(interf); interf.setUniqueId(interf.getType().toLowerCase()); - Either existInterface = titanGenericDao.getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class); + Either existInterface = janusGraphGenericDao + .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class); if (existInterface.isLeft()) { // already exist @@ -811,13 +837,14 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation } log.debug("Before adding interface type to graph {}", interfaceData); - Either createNodeResult = titanGenericDao.createNode(interfaceData, InterfaceData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(interfaceData, InterfaceData.class); log.debug("After adding property type to graph {}", interfaceData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add interface {} to graph. status is {}", interf.getType(), operationStatus); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); return result; } @@ -828,12 +855,12 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation Map newOperations = new HashMap<>(); for (Map.Entry operation : operations.entrySet()) { - Either opStatus = addOperationToGraph(interf, operation.getKey(), operation.getValue(), interfaceData); + Either opStatus = addOperationToGraph(interf, operation.getKey(), operation.getValue(), interfaceData); if (opStatus.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); log.error("Failed to add operation {} to interface {}", operation.getKey(), interf.getType()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(opStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(opStatus.right().value())); return result; } else { OperationData opData = opStatus.left().value(); @@ -849,10 +876,10 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation if (!inTransaction) { if (result == null || result.isRight()) { log.error("Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -861,14 +888,15 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation @Override public Either getInterface(String interfaceId) { - Either getResult = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class); + Either getResult = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class); if (getResult.isLeft()) { InterfaceData interfaceData = getResult.left().value(); return Either.left(convertInterfaceDataToInterfaceDefinition(interfaceData)); } else { - TitanOperationStatus titanStatus = getResult.right().value(); - log.debug("Node with id {} was not found in the graph. status: {}", interfaceId, titanStatus); - StorageOperationStatus storageOperationStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus); + JanusGraphOperationStatus janusGraphStatus = getResult.right().value(); + log.debug("Node with id {} was not found in the graph. status: {}", interfaceId, janusGraphStatus); + StorageOperationStatus storageOperationStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphStatus); return Either.right(storageOperationStatus); } } @@ -894,10 +922,11 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation @Override public Either, StorageOperationStatus> getAllInterfaceLifecycleTypes() { - Either, TitanOperationStatus> allInterfaceLifecycleTypes = - titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class); + Either, JanusGraphOperationStatus> allInterfaceLifecycleTypes = + janusGraphGenericDao + .getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class); if (allInterfaceLifecycleTypes.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus (allInterfaceLifecycleTypes.right().value())); } @@ -909,8 +938,8 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation .collect(Collectors.toList()); for (InterfaceDefinition interfaceDefinition : interfaceDefinitions) { - Either>, TitanOperationStatus> - childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), + Either>, JanusGraphOperationStatus> + childrenNodes = janusGraphGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceDefinition.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); if (childrenNodes.isLeft()) { Map operationsDataDefinitionMap = new HashMap<>(); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/OperationUtils.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/OperationUtils.java index a06d342d26..2266acf88f 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/OperationUtils.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/OperationUtils.java @@ -1,8 +1,8 @@ package org.openecomp.sdc.be.model.operations.impl; import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.operations.StorageException; @@ -14,32 +14,33 @@ import java.util.Map; @Component public class OperationUtils { - private final TitanDao titanDao; + private final JanusGraphDao janusGraphDao; private static final Logger logger = Logger.getLogger(OperationUtils.class.getName()); - public OperationUtils(TitanDao titanDao) { - this.titanDao = titanDao; + public OperationUtils(JanusGraphDao janusGraphDao) { + this.janusGraphDao = janusGraphDao; } - public T onTitanOperationFailure(TitanOperationStatus status) { - titanDao.rollback(); + public T onJanusGraphOperationFailure(JanusGraphOperationStatus status) { + janusGraphDao.rollback(); throw new StorageException(status); } - static Either, TitanOperationStatus> fillProperties(String uniqueId, - PropertyOperation propertyOperation, - NodeTypeEnum nodeTypeEnum) { + static Either, JanusGraphOperationStatus> fillProperties(String uniqueId, + PropertyOperation propertyOperation, + NodeTypeEnum nodeTypeEnum) { - Either, TitanOperationStatus> findPropertiesOfNode = + Either, JanusGraphOperationStatus> findPropertiesOfNode = propertyOperation.findPropertiesOfNode(nodeTypeEnum, uniqueId); if (findPropertiesOfNode.isRight()) { - TitanOperationStatus titanOperationStatus = findPropertiesOfNode.right().value(); - logger.debug("After looking for properties of vertex {}. status is {}", uniqueId, titanOperationStatus); - if (TitanOperationStatus.NOT_FOUND.equals(titanOperationStatus)) { - return Either.right(TitanOperationStatus.OK); + JanusGraphOperationStatus janusGraphOperationStatus = findPropertiesOfNode.right().value(); + logger.debug("After looking for properties of vertex {}. status is {}", uniqueId, + janusGraphOperationStatus); + if (JanusGraphOperationStatus.NOT_FOUND.equals(janusGraphOperationStatus)) { + return Either.right(JanusGraphOperationStatus.OK); } else { - return Either.right(titanOperationStatus); + return Either.right(janusGraphOperationStatus); } } else { return Either.left(findPropertiesOfNode.left().value()); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperation.java index 76652e1cce..e8a74fe79d 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperation.java @@ -20,12 +20,12 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.graphdb.query.TitanPredicate; +import org.janusgraph.graphdb.query.JanusGraphPredicate; import fj.data.Either; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.PolicyTypeDefinition; @@ -42,7 +42,7 @@ import org.springframework.stereotype.Component; import java.util.*; import java.util.stream.Collectors; -import static org.openecomp.sdc.be.dao.titan.TitanUtils.buildNotInPredicate; +import static org.openecomp.sdc.be.dao.janusgraph.JanusGraphUtils.buildNotInPredicate; @Component("policy-type-operation") public class PolicyTypeOperation extends AbstractOperation implements IPolicyTypeOperation { @@ -94,12 +94,13 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp @Override public List getAllPolicyTypes(Set excludedPolicyTypes) { - Map> predicateCriteria = buildNotInPredicate(GraphPropertiesDictionary.TYPE.getProperty(), excludedPolicyTypes); - return titanGenericDao.getByCriteriaWithPredicate(NodeTypeEnum.PolicyType, predicateCriteria, PolicyTypeData.class) + Map> predicateCriteria = buildNotInPredicate(GraphPropertiesDictionary.TYPE.getProperty(), excludedPolicyTypes); + return janusGraphGenericDao + .getByCriteriaWithPredicate(NodeTypeEnum.PolicyType, predicateCriteria, PolicyTypeData.class) .left() .map(this::convertPolicyTypesToDefinition) .left() - .on(operationUtils::onTitanOperationFailure); + .on(operationUtils::onJanusGraphOperationFailure); } private List convertPolicyTypesToDefinition(List policiesTypes) { @@ -113,18 +114,19 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp String ptUniqueId = UniqueIdBuilder.buildPolicyTypeUid(policyTypeDef.getType(), policyTypeDef.getVersion(), "policytype"); PolicyTypeData policyTypeData = buildPolicyTypeData(policyTypeDef, ptUniqueId); log.debug("Before adding policy type to graph. policyTypeData = {}", policyTypeData); - Either eitherPolicyTypeData = titanGenericDao.createNode(policyTypeData, PolicyTypeData.class); + Either eitherPolicyTypeData = janusGraphGenericDao + .createNode(policyTypeData, PolicyTypeData.class); log.debug("After adding policy type to graph. status is = {}", eitherPolicyTypeData); if (eitherPolicyTypeData.isRight()) { - TitanOperationStatus operationStatus = eitherPolicyTypeData.right().value(); + JanusGraphOperationStatus operationStatus = eitherPolicyTypeData.right().value(); log.error("Failed to add policy type {} to graph. status is {}", policyTypeDef.getType(), operationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); } List properties = policyTypeDef.getProperties(); - Either, TitanOperationStatus> addPropertiesToPolicyType = propertyOperation.addPropertiesToElementType(ptUniqueId, NodeTypeEnum.PolicyType, properties); + Either, JanusGraphOperationStatus> addPropertiesToPolicyType = propertyOperation.addPropertiesToElementType(ptUniqueId, NodeTypeEnum.PolicyType, properties); if (addPropertiesToPolicyType.isRight()) { log.error("Failed add properties {} to policy {}", properties, policyTypeDef.getType()); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(addPropertiesToPolicyType.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertiesToPolicyType.right().value())); } return addDerivedFromRelation(policyTypeDef, ptUniqueId) .left() @@ -139,9 +141,10 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp return result; } - Either, TitanOperationStatus> eitherPolicyData = titanGenericDao.getByCriteria(NodeTypeEnum.PolicyType, properties, PolicyTypeData.class); + Either, JanusGraphOperationStatus> eitherPolicyData = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.PolicyType, properties, PolicyTypeData.class); if (eitherPolicyData.isRight()) { - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherPolicyData.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherPolicyData.right().value())); } else { PolicyTypeDataDefinition dataDefinition = eitherPolicyData.left().value().stream().map(PolicyTypeData::getPolicyTypeDataDefinition).findFirst().get(); result = getPolicyTypeByUid(dataDefinition.getUniqueId()); @@ -152,9 +155,10 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp private Either getPolicyTypeByUid(String uniqueId) { log.debug("#getPolicyTypeByUid - fetching policy type with id {}", uniqueId); - return titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), uniqueId, PolicyTypeData.class) + return janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), uniqueId, PolicyTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(policyType -> createPolicyTypeDefinition(uniqueId, policyType)); } @@ -207,11 +211,11 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp return Either.right(err); } - Either, StorageOperationStatus> handlePolicyTypeHasNoProperties(TitanOperationStatus err) { - if (err == TitanOperationStatus.NOT_FOUND) { + Either, StorageOperationStatus> handlePolicyTypeHasNoProperties(JanusGraphOperationStatus err) { + if (err == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(new HashMap<>()); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(err)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(err)); } private PolicyTypeData setDerivedFrom(PolicyTypeDefinition policyTypeDefinition, PolicyTypeData derivedFrom) { @@ -238,9 +242,9 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp private Either updatePolicyTypeOnGraph(PolicyTypeDefinition updatedPolicyType, PolicyTypeDefinition currPolicyType) { updatePolicyTypeData(updatedPolicyType, currPolicyType); - return titanGenericDao.updateNode(new PolicyTypeData(updatedPolicyType), PolicyTypeData.class) + return janusGraphGenericDao.updateNode(new PolicyTypeData(updatedPolicyType), PolicyTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(updatedNode -> updatePolicyProperties(updatedPolicyType.getUniqueId(), updatedPolicyType.getProperties())) .left() @@ -291,7 +295,7 @@ public class PolicyTypeOperation extends AbstractOperation implements IPolicyTyp log.debug("#addPropertiesToPolicy - adding policy type properties for policy type with id {}", policyTypeId); return propertyOperation.addPropertiesToElementType(policyTypeId, NodeTypeEnum.PolicyType, properties) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } private void updatePolicyTypeData(PolicyTypeDefinition updatedTypeDefinition, PolicyTypeDefinition currTypeDefinition) { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java index fb023c7f45..54fea421a0 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java @@ -33,9 +33,9 @@ import com.google.gson.JsonParseException; import com.google.gson.JsonParser; import com.google.gson.JsonSerializationContext; import com.google.gson.JsonSerializer; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; -import com.thinkaurelius.titan.core.TitanVertexProperty; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; +import org.janusgraph.core.JanusGraphVertexProperty; import fj.data.Either; import java.io.IOException; import java.lang.reflect.Type; @@ -66,11 +66,11 @@ import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyRule; import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; @@ -132,8 +132,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public PropertyOperation(HealingTitanGenericDao titanGenericDao, DerivedFromOperation derivedFromOperation) { - this.titanGenericDao = titanGenericDao; + public PropertyOperation(HealingJanusGraphGenericDao janusGraphGenericDao, DerivedFromOperation derivedFromOperation) { + this.janusGraphGenericDao = janusGraphGenericDao; this.derivedFromOperation = derivedFromOperation; } @@ -331,9 +331,9 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe public Either addProperty(String propertyName, PropertyDefinition propertyDefinition, String resourceId) { - Either either = addPropertyToGraph(propertyName, propertyDefinition, resourceId); + Either either = addPropertyToGraph(propertyName, propertyDefinition, resourceId); if (either.isRight()) { - StorageOperationStatus storageStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value()); + StorageOperationStatus storageStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()); return Either.right(storageStatus); } return Either.left(either.left().value()); @@ -366,7 +366,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } String innerType = null; - Either checkInnerType = getInnerType(type, propertyDefinition::getSchema); + Either checkInnerType = getInnerType(type, propertyDefinition::getSchema); if (checkInnerType.isRight()) { return StorageOperationStatus.INVALID_TYPE; } @@ -392,7 +392,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return StorageOperationStatus.OK; } - public Either addPropertyToGraph(String propertyName, PropertyDefinition propertyDefinition, String resourceId) { + public Either addPropertyToGraph(String propertyName, PropertyDefinition propertyDefinition, String resourceId) { ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(resourceId); @@ -403,19 +403,21 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe PropertyData propertyData = new PropertyData(propertyDefinition, convertConstraintsToString(constraints)); log.debug(BEFORE_ADDING_PROPERTY_TO_GRAPH, propertyData); - Either createNodeResult = titanGenericDao.createNode(propertyData, PropertyData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(propertyData, PropertyData.class); log.debug(AFTER_ADDING_PROPERTY_TO_GRAPH, propertyData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add property {} to graph. status is {}", propertyName, operationStatus); return Either.right(operationStatus); } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), propertyName); - Either createRelResult = titanGenericDao.createRelation(resourceData, propertyData, GraphEdgeLabels.PROPERTY, props); + Either createRelResult = janusGraphGenericDao + .createRelation(resourceData, propertyData, GraphEdgeLabels.PROPERTY, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error(FAILED_TO_ASSOCIATE_RESOURCE_TO_PROPERTY_IN_GRAPH_STATUS_IS, resourceId, propertyName, operationStatus); return Either.right(operationStatus); } @@ -424,7 +426,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public TitanOperationStatus addPropertyToGraphByVertex(TitanVertex metadataVertex, String propertyName, PropertyDefinition propertyDefinition, String resourceId) { + public JanusGraphOperationStatus addPropertyToGraphByVertex(JanusGraphVertex metadataVertex, String propertyName, PropertyDefinition propertyDefinition, String resourceId) { List constraints = propertyDefinition.getConstraints(); @@ -432,19 +434,21 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe PropertyData propertyData = new PropertyData(propertyDefinition, convertConstraintsToString(constraints)); log.debug(BEFORE_ADDING_PROPERTY_TO_GRAPH, propertyData); - Either createNodeResult = titanGenericDao.createNode(propertyData); + Either createNodeResult = janusGraphGenericDao.createNode(propertyData); log.debug(AFTER_ADDING_PROPERTY_TO_GRAPH, propertyData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add property {} to graph. status is ", propertyName, operationStatus); return operationStatus; } Map props = new HashMap<>(); props.put(GraphPropertiesDictionary.NAME.getProperty(), propertyName); - TitanVertex propertyVertex = createNodeResult.left().value(); - TitanOperationStatus createRelResult = titanGenericDao.createEdge(metadataVertex, propertyVertex, GraphEdgeLabels.PROPERTY, props); - if (!createRelResult.equals(TitanOperationStatus.OK)) { + JanusGraphVertex propertyVertex = createNodeResult.left().value(); + JanusGraphOperationStatus + createRelResult = janusGraphGenericDao + .createEdge(metadataVertex, propertyVertex, GraphEdgeLabels.PROPERTY, props); + if (!createRelResult.equals(JanusGraphOperationStatus.OK)) { log.error(FAILED_TO_ASSOCIATE_RESOURCE_TO_PROPERTY_IN_GRAPH_STATUS_IS, resourceId, propertyName, createRelResult); return createRelResult; } @@ -453,13 +457,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public TitanGenericDao getTitanGenericDao() { - return titanGenericDao; + public JanusGraphGenericDao getJanusGraphGenericDao() { + return janusGraphGenericDao; } - public Either deletePropertyFromGraph(String propertyId) { + public Either deletePropertyFromGraph(String propertyId) { log.debug("Before deleting property from graph {}", propertyId); - return titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); + return janusGraphGenericDao + .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); } public Either updateProperty(String propertyId, PropertyDefinition newPropertyDefinition, Map dataTypes) { @@ -469,20 +474,21 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return Either.right(validateAndUpdateProperty); } - Either either = updatePropertyFromGraph(propertyId, newPropertyDefinition); + Either either = updatePropertyFromGraph(propertyId, newPropertyDefinition); if (either.isRight()) { - StorageOperationStatus storageStatus = DaoStatusConverter.convertTitanStatusToStorageStatus(either.right().value()); + StorageOperationStatus storageStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()); return Either.right(storageStatus); } return Either.left(either.left().value()); } - public Either updatePropertyFromGraph(String propertyId, PropertyDefinition propertyDefinition) { + public Either updatePropertyFromGraph(String propertyId, PropertyDefinition propertyDefinition) { if (log.isDebugEnabled()) log.debug("Before updating property on graph {}", propertyId); // get the original property data - Either statusProperty = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); + Either statusProperty = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Property), propertyId, PropertyData.class); if (statusProperty.isRight()) { log.debug("Problem while get property with id {}. Reason - {}", propertyId, statusProperty.right().value().name()); return Either.right(statusProperty.right().value()); @@ -518,19 +524,19 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } orgPropertyDataDefinition.setSchema(newPropertyDataDefinition.getSchema()); - return titanGenericDao.updateNode(orgPropertyData, PropertyData.class); + return janusGraphGenericDao.updateNode(orgPropertyData, PropertyData.class); } /** * FOR TEST ONLY * - * @param titanGenericDao + * @param janusGraphGenericDao */ - public void setTitanGenericDao(HealingTitanGenericDao titanGenericDao) { - this.titanGenericDao = titanGenericDao; + public void setJanusGraphGenericDao(HealingJanusGraphGenericDao janusGraphGenericDao) { + this.janusGraphGenericDao = janusGraphGenericDao; } - public Either addPropertyToNodeType(String propertyName, PropertyDefinition propertyDefinition, NodeTypeEnum nodeType, String uniqueId) { + public Either addPropertyToNodeType(String propertyName, PropertyDefinition propertyDefinition, NodeTypeEnum nodeType, String uniqueId) { List constraints = propertyDefinition.getConstraints(); @@ -539,11 +545,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (log.isDebugEnabled()) log.debug(BEFORE_ADDING_PROPERTY_TO_GRAPH, propertyData); - Either createNodeResult = titanGenericDao.createNode(propertyData, PropertyData.class); + Either createNodeResult = janusGraphGenericDao + .createNode(propertyData, PropertyData.class); if (log.isDebugEnabled()) log.debug(AFTER_ADDING_PROPERTY_TO_GRAPH, propertyData); if (createNodeResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error("Failed to add property {} to graph. status is {}", propertyName, operationStatus); return Either.right(operationStatus); } @@ -553,9 +560,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe UniqueIdData uniqueIdData = new UniqueIdData(nodeType, uniqueId); log.debug("Before associating {} to property {}", uniqueIdData, propertyName); - Either createRelResult = titanGenericDao.createRelation(uniqueIdData, propertyData, GraphEdgeLabels.PROPERTY, props); + Either createRelResult = janusGraphGenericDao + .createRelation(uniqueIdData, propertyData, GraphEdgeLabels.PROPERTY, props); if (createRelResult.isRight()) { - TitanOperationStatus operationStatus = createNodeResult.right().value(); + JanusGraphOperationStatus operationStatus = createNodeResult.right().value(); log.error(FAILED_TO_ASSOCIATE_RESOURCE_TO_PROPERTY_IN_GRAPH_STATUS_IS, uniqueId, propertyName, operationStatus); return Either.right(operationStatus); } @@ -564,15 +572,16 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> findPropertiesOfNode(NodeTypeEnum nodeType, String uniqueId) { + public Either, JanusGraphOperationStatus> findPropertiesOfNode(NodeTypeEnum nodeType, String uniqueId) { Map resourceProps = new HashMap<>(); - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.PROPERTY, NodeTypeEnum.Property, + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.PROPERTY, NodeTypeEnum.Property, PropertyData.class); if (childrenNodes.isRight()) { - TitanOperationStatus operationStatus = childrenNodes.right().value(); + JanusGraphOperationStatus operationStatus = childrenNodes.right().value(); return Either.right(operationStatus); } @@ -600,15 +609,15 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe .bind(err -> err == StorageOperationStatus.OK ? Either.left(Collections.emptyMap()) : Either.right(err)); } - public Either, TitanOperationStatus> mergePropertiesAssociatedToNode(NodeTypeEnum nodeType, String uniqueId, Map newProperties) { - Either, TitanOperationStatus> oldPropertiesRes = findPropertiesOfNode(nodeType, uniqueId); + public Either, JanusGraphOperationStatus> mergePropertiesAssociatedToNode(NodeTypeEnum nodeType, String uniqueId, Map newProperties) { + Either, JanusGraphOperationStatus> oldPropertiesRes = findPropertiesOfNode(nodeType, uniqueId); Map reallyNewProperties; Map unchangedPropsData; if (oldPropertiesRes.isRight()) { - TitanOperationStatus err = oldPropertiesRes.right().value(); - if (err == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus err = oldPropertiesRes.right().value(); + if (err == JanusGraphOperationStatus.NOT_FOUND) { reallyNewProperties = newProperties; unchangedPropsData = Collections.emptyMap(); } @@ -625,8 +634,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe PropertyDefinition newPropDef = newProperties != null? newProperties.get(key): null; PropertyDefinition oldPropDef = oldEntry.getValue(); - TitanOperationStatus status = updateOldProperty(newPropDef, oldPropDef); - if (status != TitanOperationStatus.OK) { + JanusGraphOperationStatus status = updateOldProperty(newPropDef, oldPropDef); + if (status != JanusGraphOperationStatus.OK) { return Either.right(status); } } @@ -654,9 +663,9 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param newPropDef * @param oldPropDef */ - private TitanOperationStatus updateOldProperty(PropertyDefinition newPropDef, PropertyDefinition oldPropDef) { + private JanusGraphOperationStatus updateOldProperty(PropertyDefinition newPropDef, PropertyDefinition oldPropDef) { if (!isUpdateAllowed(newPropDef, oldPropDef)) { - return TitanOperationStatus.MATCH_NOT_FOUND; + return JanusGraphOperationStatus.MATCH_NOT_FOUND; } if (isUpdateRequired(newPropDef, oldPropDef)) { @@ -664,14 +673,15 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe List constraints = oldPropDef.getConstraints(); PropertyData node = new PropertyData(oldPropDef, convertConstraintsToString(constraints)); - Either updateResult = titanGenericDao.updateNode(node, PropertyData.class); + Either updateResult = janusGraphGenericDao + .updateNode(node, PropertyData.class); if (updateResult.isRight()) { return updateResult.right().value(); } } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } /** @@ -703,7 +713,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe oldPropDef.setDescription(newPropDef.getDescription()); oldPropDef.setRequired(newPropDef.isRequired()); - // Type is updated to fix possible null type issue in TITAN DB + // Type is updated to fix possible null type issue in janusGraph DB oldPropDef.setType(newPropDef.getType()); } @@ -723,7 +733,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param unchangedPropsData * @return */ - private Either, TitanOperationStatus> addPropertiesToElementType(NodeTypeEnum nodeType, String uniqueId, Map newProperties, Map unchangedPropsData) { + private Either, JanusGraphOperationStatus> addPropertiesToElementType(NodeTypeEnum nodeType, String uniqueId, Map newProperties, Map unchangedPropsData) { return addPropertiesToElementType(uniqueId, nodeType, newProperties) .left() .map(m -> { @@ -735,28 +745,28 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe public Either, StorageOperationStatus> deleteAllPropertiesAssociatedToNode(NodeTypeEnum nodeType, String uniqueId) { - Either, TitanOperationStatus> propertiesOfNodeRes = findPropertiesOfNode(nodeType, uniqueId); + Either, JanusGraphOperationStatus> propertiesOfNodeRes = findPropertiesOfNode(nodeType, uniqueId); if (propertiesOfNodeRes.isRight()) { - TitanOperationStatus status = propertiesOfNodeRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = propertiesOfNodeRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.right(StorageOperationStatus.OK); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } Map value = propertiesOfNodeRes.left().value(); for (PropertyDefinition propertyDefinition : value.values()) { String propertyUid = propertyDefinition.getUniqueId(); - Either deletePropertyRes = deletePropertyFromGraph(propertyUid); + Either deletePropertyRes = deletePropertyFromGraph(propertyUid); if (deletePropertyRes.isRight()) { log.error("Failed to delete property with id {}", propertyUid); - TitanOperationStatus status = deletePropertyRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = deletePropertyRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } } @@ -855,13 +865,13 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return rules; } - public ImmutablePair findPropertyValue(String resourceInstanceId, String propertyId) { + public ImmutablePair findPropertyValue(String resourceInstanceId, String propertyId) { log.debug("Going to check whether the property {} already added to resource instance {}", propertyId, resourceInstanceId); - Either, TitanOperationStatus> getAllRes = this.getAllPropertiesOfResourceInstanceOnlyPropertyDefId(resourceInstanceId); + Either, JanusGraphOperationStatus> getAllRes = this.getAllPropertiesOfResourceInstanceOnlyPropertyDefId(resourceInstanceId); if (getAllRes.isRight()) { - TitanOperationStatus status = getAllRes.right().value(); + JanusGraphOperationStatus status = getAllRes.right().value(); log.trace("After fetching all properties of resource instance {}. Status is {}", resourceInstanceId, status); return new ImmutablePair<>(status, null); } @@ -874,12 +884,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe log.trace("Go over property {} under resource instance {}. valueUniqueId = {}", propertyUniqueId, resourceInstanceId, valueUniqueUid); if (propertyId.equals(propertyUniqueId) && valueUniqueUid != null) { log.debug("The property {} already created under resource instance {}", propertyId, resourceInstanceId); - return new ImmutablePair<>(TitanOperationStatus.ALREADY_EXIST, valueUniqueUid); + return new ImmutablePair<>(JanusGraphOperationStatus.ALREADY_EXIST, valueUniqueUid); } } } - return new ImmutablePair<>(TitanOperationStatus.NOT_FOUND, null); + return new ImmutablePair<>(JanusGraphOperationStatus.NOT_FOUND, null); } @@ -960,45 +970,49 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param resourceInstanceUid * @return */ - public Either, TitanOperationStatus> getAllPropertiesOfResourceInstanceOnlyPropertyDefId(String resourceInstanceUid) { + public Either, JanusGraphOperationStatus> getAllPropertiesOfResourceInstanceOnlyPropertyDefId(String resourceInstanceUid) { return getAllPropertiesOfResourceInstanceOnlyPropertyDefId(resourceInstanceUid, NodeTypeEnum.ResourceInstance); } - public Either removePropertyOfResourceInstance(String propertyValueUid, String resourceInstanceId) { + public Either removePropertyOfResourceInstance(String propertyValueUid, String resourceInstanceId) { - Either findResInstanceRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, ComponentInstanceData.class); + Either findResInstanceRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, ComponentInstanceData.class); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } - Either findPropertyDefRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, PropertyValueData.class); + Either findPropertyDefRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, PropertyValueData.class); if (findPropertyDefRes.isRight()) { - TitanOperationStatus status = findPropertyDefRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findPropertyDefRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } - Either relation = titanGenericDao.getRelation(findResInstanceRes.left().value(), findPropertyDefRes.left().value(), GraphEdgeLabels.PROPERTY_VALUE); + Either relation = janusGraphGenericDao + .getRelation(findResInstanceRes.left().value(), findPropertyDefRes.left().value(), GraphEdgeLabels.PROPERTY_VALUE); if (relation.isRight()) { // TODO: add error in case of error - TitanOperationStatus status = relation.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = relation.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } - Either deleteNode = titanGenericDao.deleteNode(findPropertyDefRes.left().value(), PropertyValueData.class); + Either deleteNode = janusGraphGenericDao + .deleteNode(findPropertyDefRes.left().value(), PropertyValueData.class); if (deleteNode.isRight()) { return Either.right(deleteNode.right().value()); } @@ -1013,11 +1027,11 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe try { - Either eitherStatus = this.removePropertyOfResourceInstance(propertyValueUid, resourceInstanceId); + Either eitherStatus = this.removePropertyOfResourceInstance(propertyValueUid, resourceInstanceId); if (eitherStatus.isRight()) { log.error("Failed to remove property value {} from resource instance {} in Graph. status is {}", propertyValueUid, resourceInstanceId, eitherStatus.right().value().name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); return result; } else { PropertyValueData propertyValueData = eitherStatus.left().value(); @@ -1036,10 +1050,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -1111,7 +1125,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (ToscaPropertyType.isValidType(property.getType()) == null) { - Either definedInDataTypes = isDefinedInDataTypes(property.getType()); + Either definedInDataTypes = isDefinedInDataTypes(property.getType()); if (definedInDataTypes.isRight()) { return false; @@ -1164,44 +1178,50 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> getAllPropertiesOfResourceInstanceOnlyPropertyDefId(String resourceInstanceUid, NodeTypeEnum instanceNodeType) { + public Either, JanusGraphOperationStatus> getAllPropertiesOfResourceInstanceOnlyPropertyDefId(String resourceInstanceUid, NodeTypeEnum instanceNodeType) { - Either findResInstanceRes = titanGenericDao.getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid); + Either findResInstanceRes = janusGraphGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid); if (findResInstanceRes.isRight()) { - TitanOperationStatus status = findResInstanceRes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = findResInstanceRes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } - Either>, TitanOperationStatus> propertyImplNodes = titanGenericDao.getChildrenVertecies(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, GraphEdgeLabels.PROPERTY_VALUE); + Either>, JanusGraphOperationStatus> propertyImplNodes = janusGraphGenericDao + .getChildrenVertecies(UniqueIdBuilder.getKeyByNodeType(instanceNodeType), resourceInstanceUid, GraphEdgeLabels.PROPERTY_VALUE); if (propertyImplNodes.isRight()) { - TitanOperationStatus status = propertyImplNodes.right().value(); + JanusGraphOperationStatus status = propertyImplNodes.right().value(); return Either.right(status); } - List> list = propertyImplNodes.left().value(); + List> list = propertyImplNodes.left().value(); if (list == null || list.isEmpty()) { - return Either.right(TitanOperationStatus.NOT_FOUND); + return Either.right(JanusGraphOperationStatus.NOT_FOUND); } List result = new ArrayList<>(); - for (ImmutablePair propertyValue : list) { - TitanVertex propertyValueDataVertex = propertyValue.getLeft(); - String propertyValueUid = (String) titanGenericDao.getProperty(propertyValueDataVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); - String value = (String) titanGenericDao.getProperty(propertyValueDataVertex, GraphPropertiesDictionary.VALUE.getProperty()); - - ImmutablePair propertyDefPair = titanGenericDao.getChildVertex(propertyValueDataVertex, GraphEdgeLabels.PROPERTY_IMPL); + for (ImmutablePair propertyValue : list) { + JanusGraphVertex propertyValueDataVertex = propertyValue.getLeft(); + String propertyValueUid = (String) janusGraphGenericDao + .getProperty(propertyValueDataVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + String value = (String) janusGraphGenericDao + .getProperty(propertyValueDataVertex, GraphPropertiesDictionary.VALUE.getProperty()); + + ImmutablePair propertyDefPair = janusGraphGenericDao + .getChildVertex(propertyValueDataVertex, GraphEdgeLabels.PROPERTY_IMPL); if (propertyDefPair == null) { - return Either.right(TitanOperationStatus.NOT_FOUND); + return Either.right(JanusGraphOperationStatus.NOT_FOUND); } - Map properties = titanGenericDao.getProperties(propertyValueDataVertex); + Map properties = janusGraphGenericDao.getProperties(propertyValueDataVertex); PropertyValueData propertyValueData = GraphElementFactory.createElement(NodeTypeEnum.PropertyValue.getName(), GraphElementTypeEnum.Node, properties, PropertyValueData.class); - String propertyUniqueId = (String) titanGenericDao.getProperty(propertyDefPair.left, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + String propertyUniqueId = (String) janusGraphGenericDao + .getProperty(propertyDefPair.left, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); ComponentInstanceProperty resourceInstanceProperty = new ComponentInstanceProperty(); // set property original unique id @@ -1230,7 +1250,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param defaultValue * @return */ - public Either findDefaultValueFromSecondPosition(List pathOfComponentInstances, String propertyUniqueId, String defaultValue) { + public Either findDefaultValueFromSecondPosition(List pathOfComponentInstances, String propertyUniqueId, String defaultValue) { log.trace("In find default value: path= {} propertyUniqId={} defaultValue= {}", pathOfComponentInstances, propertyUniqueId, defaultValue); @@ -1243,13 +1263,13 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe for (int i = 1; i < pathOfComponentInstances.size(); i++) { String compInstanceId = pathOfComponentInstances.get(i); - Either, TitanOperationStatus> propertyValuesResult = this.getAllPropertiesOfResourceInstanceOnlyPropertyDefId(compInstanceId, NodeTypeEnum.ResourceInstance); + Either, JanusGraphOperationStatus> propertyValuesResult = this.getAllPropertiesOfResourceInstanceOnlyPropertyDefId(compInstanceId, NodeTypeEnum.ResourceInstance); log.trace("After fetching properties values of component instance {}. {}", compInstanceId, propertyValuesResult); if (propertyValuesResult.isRight()) { - TitanOperationStatus status = propertyValuesResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = propertyValuesResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return Either.right(status); } else { continue; @@ -1459,7 +1479,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param dataTypeDefinition * @return */ - private Either addDataTypeToGraph(DataTypeDefinition dataTypeDefinition) { + private Either addDataTypeToGraph(DataTypeDefinition dataTypeDefinition) { log.debug("Got data type {}", dataTypeDefinition); @@ -1468,11 +1488,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData dataTypeData = buildDataTypeData(dataTypeDefinition, dtUniqueId); log.debug("Before adding data type to graph. dataTypeData = {}", dataTypeData); - Either createDataTypeResult = titanGenericDao.createNode(dataTypeData, DataTypeData.class); + Either createDataTypeResult = janusGraphGenericDao + .createNode(dataTypeData, DataTypeData.class); log.debug("After adding data type to graph. status is = {}", createDataTypeResult); if (createDataTypeResult.isRight()) { - TitanOperationStatus operationStatus = createDataTypeResult.right().value(); + JanusGraphOperationStatus operationStatus = createDataTypeResult.right().value(); log.debug("Failed to data type {} to graph. status is {}", dataTypeDefinition.getName(), operationStatus); BeEcompErrorManager.getInstance().logBeFailedAddingNodeTypeError("AddDataType", NodeTypeEnum.DataType.getName()); return Either.right(operationStatus); @@ -1480,7 +1501,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData resultCTD = createDataTypeResult.left().value(); List properties = dataTypeDefinition.getProperties(); - Either, TitanOperationStatus> addPropertiesToDataType = addPropertiesToDataType(resultCTD.getUniqueId(), properties); + Either, JanusGraphOperationStatus> addPropertiesToDataType = addPropertiesToDataType(resultCTD.getUniqueId(), properties); if (addPropertiesToDataType.isRight()) { log.debug("Failed add properties {} to data type {}", properties, dataTypeDefinition.getName()); return Either.right(addPropertiesToDataType.right().value()); @@ -1493,7 +1514,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe String deriveFromUid = UniqueIdBuilder.buildDataTypeUid(derivedFrom); UniqueIdData to = new UniqueIdData(NodeTypeEnum.DataType, deriveFromUid); - Either createRelation = titanGenericDao.createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null); + Either createRelation = janusGraphGenericDao + .createRelation(from, to, GraphEdgeLabels.DERIVED_FROM, null); log.debug("After create relation between capability type {} to its parent {}. status is {}", dtUniqueId, derivedFrom, createRelation); if (createRelation.isRight()) { return Either.right(createRelation.right().value()); @@ -1528,7 +1550,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param properties * @return */ - private Either, TitanOperationStatus> addPropertiesToDataType(String uniqueId, List properties) { + private Either, JanusGraphOperationStatus> addPropertiesToDataType(String uniqueId, List properties) { Map propertiesData = new HashMap<>(); @@ -1537,7 +1559,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe String propertyName = propertyDefinition.getName(); String propertyType = propertyDefinition.getType(); - Either validPropertyType = isValidPropertyType(propertyType); + Either validPropertyType = isValidPropertyType(propertyType); if (validPropertyType.isRight()) { log.debug("Data type {} contains invalid property type {}", uniqueId, propertyType); return Either.right(validPropertyType.right().value()); @@ -1545,12 +1567,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe Boolean isValid = validPropertyType.left().value(); if (isValid == null || !isValid.booleanValue()) { log.debug("Data type {} contains invalid property type {}", uniqueId, propertyType); - return Either.right(TitanOperationStatus.INVALID_TYPE); + return Either.right(JanusGraphOperationStatus.INVALID_TYPE); } - Either addPropertyToNodeType = this.addPropertyToNodeType(propertyName, propertyDefinition, NodeTypeEnum.DataType, uniqueId); + Either addPropertyToNodeType = this.addPropertyToNodeType(propertyName, propertyDefinition, NodeTypeEnum.DataType, uniqueId); if (addPropertyToNodeType.isRight()) { - TitanOperationStatus operationStatus = addPropertyToNodeType.right().value(); + JanusGraphOperationStatus operationStatus = addPropertyToNodeType.right().value(); log.debug("Failed to associate data type {} to property {} in graph. status is {}", uniqueId, propertyName, operationStatus); BeEcompErrorManager.getInstance().logInternalFlowError("AddPropertyToDataType", "Failed to associate property to data type. Status is " + operationStatus, ErrorSeverity.ERROR); return Either.right(operationStatus); @@ -1563,9 +1585,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe long modificationTime = System.currentTimeMillis(); dataTypeData.getDataTypeDataDefinition().setModificationTime(modificationTime); - Either updateNode = titanGenericDao.updateNode(dataTypeData, DataTypeData.class); + Either updateNode = janusGraphGenericDao + .updateNode(dataTypeData, DataTypeData.class); if (updateNode.isRight()) { - TitanOperationStatus operationStatus = updateNode.right().value(); + JanusGraphOperationStatus operationStatus = updateNode.right().value(); log.debug("Failed to update modification time data type {} from graph. status is {}", uniqueId, operationStatus); BeEcompErrorManager.getInstance().logInternalFlowError("AddPropertyToDataType", "Failed to fetch data type. Status is " + operationStatus, ErrorSeverity.ERROR); return Either.right(operationStatus); @@ -1585,14 +1608,15 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param uniqueId * @return */ - public Either getDataTypeByUid(String uniqueId) { + public Either getDataTypeByUid(String uniqueId) { - Either result = null; + Either result = null; - Either dataTypesRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); + Either dataTypesRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); if (dataTypesRes.isRight()) { - TitanOperationStatus status = dataTypesRes.right().value(); + JanusGraphOperationStatus status = dataTypesRes.right().value(); log.debug(DATA_TYPE_CANNOT_BE_FOUND_IN_GRAPH_STATUS_IS, uniqueId, status); return Either.right(status); } @@ -1600,20 +1624,22 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData ctData = dataTypesRes.left().value(); DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(ctData.getDataTypeDataDefinition()); - TitanOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); - if (propertiesStatus != TitanOperationStatus.OK) { + JanusGraphOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); + if (propertiesStatus != JanusGraphOperationStatus.OK) { log.error(FAILED_TO_FETCH_PROPERTIES_OF_DATA_TYPE, uniqueId); return Either.right(propertiesStatus); } - Either, TitanOperationStatus> parentNode = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.DataType, + Either, JanusGraphOperationStatus> parentNode = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.DataType, DataTypeData.class); log.debug("After retrieving DERIVED_FROM node of {}. status is {}", uniqueId, parentNode); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus != TitanOperationStatus.NOT_FOUND) { - log.error("Failed to find the parent data type of data type {}. status is {}", uniqueId, titanOperationStatus); - result = Either.right(titanOperationStatus); + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) { + log.error("Failed to find the parent data type of data type {}. status is {}", uniqueId, + janusGraphOperationStatus); + result = Either.right(janusGraphOperationStatus); return result; } } else { @@ -1622,7 +1648,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData parentCT = immutablePair.getKey(); String parentUniqueId = parentCT.getUniqueId(); - Either dataTypeByUid = getDataTypeByUid(parentUniqueId); + Either dataTypeByUid = getDataTypeByUid(parentUniqueId); if (dataTypeByUid.isRight()) { return Either.right(dataTypeByUid.right().value()); @@ -1638,16 +1664,17 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return result; } - private TitanOperationStatus fillProperties(String uniqueId, DataTypeDefinition dataTypeDefinition) { + private JanusGraphOperationStatus fillProperties(String uniqueId, DataTypeDefinition dataTypeDefinition) { - Either, TitanOperationStatus> findPropertiesOfNode = this.findPropertiesOfNode(NodeTypeEnum.DataType, uniqueId); + Either, JanusGraphOperationStatus> findPropertiesOfNode = this.findPropertiesOfNode(NodeTypeEnum.DataType, uniqueId); if (findPropertiesOfNode.isRight()) { - TitanOperationStatus titanOperationStatus = findPropertiesOfNode.right().value(); - log.debug("After looking for properties of vertex {}. status is {}", uniqueId, titanOperationStatus); - if (TitanOperationStatus.NOT_FOUND.equals(titanOperationStatus)) { - return TitanOperationStatus.OK; + JanusGraphOperationStatus janusGraphOperationStatus = findPropertiesOfNode.right().value(); + log.debug("After looking for properties of vertex {}. status is {}", uniqueId, + janusGraphOperationStatus); + if (JanusGraphOperationStatus.NOT_FOUND.equals(janusGraphOperationStatus)) { + return JanusGraphOperationStatus.OK; } else { - return titanOperationStatus; + return janusGraphOperationStatus; } } else { Map properties = findPropertiesOfNode.left().value(); @@ -1663,7 +1690,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } dataTypeDefinition.setProperties(listOfProps); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } } @@ -1673,12 +1700,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe try { - Either eitherStatus = addDataTypeToGraph(dataTypeDefinition); + Either eitherStatus = addDataTypeToGraph(dataTypeDefinition); if (eitherStatus.isRight()) { log.debug("Failed to add data type {} to Graph. status is {}", dataTypeDefinition, eitherStatus.right().value().name()); BeEcompErrorManager.getInstance().logBeFailedAddingNodeTypeError("AddDataType", "DataType"); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(eitherStatus.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value())); return result; } else { DataTypeData capabilityTypeData = eitherStatus.left().value(); @@ -1692,10 +1719,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -1714,14 +1741,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe try { String dtUid = UniqueIdBuilder.buildDataTypeUid(name); - Either ctResult = this.getDataTypeByUid(dtUid); + Either ctResult = this.getDataTypeByUid(dtUid); if (ctResult.isRight()) { - TitanOperationStatus status = ctResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = ctResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { log.error("Failed to retrieve information on capability type {} status is {}", name, status); } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(ctResult.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(ctResult.right().value())); return result; } @@ -1732,10 +1759,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -1758,14 +1785,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe try { String uid = UniqueIdBuilder.buildDataTypeUid(name); - Either ctResult = this.getDataTypeByUidWithoutDerivedDataTypes(uid); + Either ctResult = this.getDataTypeByUidWithoutDerivedDataTypes(uid); if (ctResult.isRight()) { - TitanOperationStatus status = ctResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = ctResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { log.error("Failed to retrieve information on capability type {} status is {}", name, status); } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(ctResult.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(ctResult.right().value())); return result; } @@ -1776,22 +1803,23 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } } - public Either getDataTypeByUidWithoutDerivedDataTypes(String uniqueId) { + public Either getDataTypeByUidWithoutDerivedDataTypes(String uniqueId) { - Either dataTypesRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); + Either dataTypesRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); if (dataTypesRes.isRight()) { - TitanOperationStatus status = dataTypesRes.right().value(); + JanusGraphOperationStatus status = dataTypesRes.right().value(); log.debug(DATA_TYPE_CANNOT_BE_FOUND_IN_GRAPH_STATUS_IS, uniqueId, status); return Either.right(status); } @@ -1799,8 +1827,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData ctData = dataTypesRes.left().value(); DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(ctData.getDataTypeDataDefinition()); - TitanOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); - if (propertiesStatus != TitanOperationStatus.OK) { + JanusGraphOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); + if (propertiesStatus != JanusGraphOperationStatus.OK) { log.error(FAILED_TO_FETCH_PROPERTIES_OF_DATA_TYPE, uniqueId); return Either.right(propertiesStatus); } @@ -1821,7 +1849,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return new DataTypeDefinition(dataTypeData.getDataTypeDataDefinition()); } - private Either isValidPropertyType(String propertyType) { + private Either isValidPropertyType(String propertyType) { if (propertyType == null || propertyType.isEmpty()) { return Either.left(false); @@ -1835,13 +1863,13 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } } - public Either isDefinedInDataTypes(String propertyType) { + public Either isDefinedInDataTypes(String propertyType) { String dataTypeUid = UniqueIdBuilder.buildDataTypeUid(propertyType); - Either dataTypeByUid = getDataTypeByUid(dataTypeUid); + Either dataTypeByUid = getDataTypeByUid(dataTypeUid); if (dataTypeByUid.isRight()) { - TitanOperationStatus status = dataTypeByUid.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = dataTypeByUid.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(false); } return Either.right(status); @@ -1851,15 +1879,16 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> getAllDataTypes() { + public Either, JanusGraphOperationStatus> getAllDataTypes() { Map dataTypes = new HashMap<>(); - Either, TitanOperationStatus> result = Either.left(dataTypes); + Either, JanusGraphOperationStatus> result = Either.left(dataTypes); - Either, TitanOperationStatus> getAllDataTypes = titanGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class); + Either, JanusGraphOperationStatus> getAllDataTypes = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class); if (getAllDataTypes.isRight()) { - TitanOperationStatus status = getAllDataTypes.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = getAllDataTypes.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return Either.right(status); } else { return result; @@ -1877,11 +1906,11 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe for (DataTypeData dataTypeData : list) { log.trace("Going to fetch data type {}. uid is {}", dataTypeData.getDataTypeDataDefinition().getName(), dataTypeData.getUniqueId()); - Either dataTypeByUid = this.getAndAddDataTypeByUid(dataTypeData.getUniqueId(), dataTypes); + Either dataTypeByUid = this.getAndAddDataTypeByUid(dataTypeData.getUniqueId(), dataTypes); if (dataTypeByUid.isRight()) { - TitanOperationStatus status = dataTypeByUid.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = dataTypeByUid.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -1909,18 +1938,19 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @param uniqueId * @return */ - private Either getAndAddDataTypeByUid(String uniqueId, Map allDataTypes) { + private Either getAndAddDataTypeByUid(String uniqueId, Map allDataTypes) { - Either result = null; + Either result = null; if (allDataTypes.containsKey(uniqueId)) { return Either.left(allDataTypes.get(uniqueId)); } - Either dataTypesRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); + Either dataTypesRes = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, DataTypeData.class); if (dataTypesRes.isRight()) { - TitanOperationStatus status = dataTypesRes.right().value(); + JanusGraphOperationStatus status = dataTypesRes.right().value(); log.debug(DATA_TYPE_CANNOT_BE_FOUND_IN_GRAPH_STATUS_IS, uniqueId, status); return Either.right(status); } @@ -1928,8 +1958,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData ctData = dataTypesRes.left().value(); DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(ctData.getDataTypeDataDefinition()); - TitanOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); - if (propertiesStatus != TitanOperationStatus.OK) { + JanusGraphOperationStatus propertiesStatus = fillProperties(uniqueId, dataTypeDefinition); + if (propertiesStatus != JanusGraphOperationStatus.OK) { log.error(FAILED_TO_FETCH_PROPERTIES_OF_DATA_TYPE, uniqueId); return Either.right(propertiesStatus); } @@ -1945,14 +1975,16 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return Either.left(dataTypeDefinition); } - Either, TitanOperationStatus> parentNode = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.DataType, + Either, JanusGraphOperationStatus> parentNode = janusGraphGenericDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.DataType, DataTypeData.class); log.debug("After retrieving DERIVED_FROM node of {}. status is {}", uniqueId, parentNode); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus != TitanOperationStatus.NOT_FOUND) { - log.error("Failed to find the parent data type of data type {}. status is {}", uniqueId, titanOperationStatus); - result = Either.right(titanOperationStatus); + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) { + log.error("Failed to find the parent data type of data type {}. status is {}", uniqueId, + janusGraphOperationStatus); + result = Either.right(janusGraphOperationStatus); return result; } } else { @@ -1961,7 +1993,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe DataTypeData parentCT = immutablePair.getKey(); String parentUniqueId = parentCT.getUniqueId(); - Either dataTypeByUid = getDataTypeByUid(parentUniqueId); + Either dataTypeByUid = getDataTypeByUid(parentUniqueId); if (dataTypeByUid.isRight()) { return Either.right(dataTypeByUid.right().value()); @@ -1977,12 +2009,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return result; } - private Either getDataTypeUsingName(String name) { + private Either getDataTypeUsingName(String name) { String uid = UniqueIdBuilder.buildDataTypeUid(name); return getDataTypeByUid(uid); } - public Either checkInnerType(PropertyDataDefinition propDataDef) { + public Either checkInnerType(PropertyDataDefinition propDataDef) { String propertyType = propDataDef.getType(); @@ -1991,12 +2023,13 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return getInnerType(type, propDataDef::getSchema); } - public Either, TitanOperationStatus> getAllDataTypeNodes() { - Either, TitanOperationStatus> getAllDataTypes = titanGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class); + public Either, JanusGraphOperationStatus> getAllDataTypeNodes() { + Either, JanusGraphOperationStatus> getAllDataTypes = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class); if (getAllDataTypes.isRight()) { - TitanOperationStatus status = getAllDataTypes.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.OK; + JanusGraphOperationStatus status = getAllDataTypes.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.OK; return Either.right(status); } } @@ -2047,11 +2080,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe .bind(props -> getAllDerivedFromChainProperties(uniqueId, nodeType, clazz, props.values())); } - private Either, StorageOperationStatus> handleNotFoundProperties(TitanOperationStatus titanOperationStatus) { - if (titanOperationStatus == TitanOperationStatus.NOT_FOUND) { + private Either, StorageOperationStatus> handleNotFoundProperties(JanusGraphOperationStatus janusGraphOperationStatus) { + if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(new HashMap<>()); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } private Either, StorageOperationStatus> getAllDerivedFromChainProperties(String uniqueId, NodeTypeEnum nodeType, Class clazz, Collection nodeProps) { @@ -2060,10 +2094,12 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe Either derivedFrom; while ((derivedFrom = derivedFromOperation.getDerivedFromChild(currentNodeUid, nodeType, clazz)).isLeft()) { currentNodeUid = derivedFrom.left().value().getUniqueId(); - TitanOperationStatus titanOperationStatus = fillPropertiesList(currentNodeUid, nodeType, accumulatedProps::addAll); - if (titanOperationStatus != TitanOperationStatus.OK) { + JanusGraphOperationStatus + janusGraphOperationStatus = fillPropertiesList(currentNodeUid, nodeType, accumulatedProps::addAll); + if (janusGraphOperationStatus != JanusGraphOperationStatus.OK) { log.debug("failed to fetch properties for type {} with id {}", nodeType, currentNodeUid); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanOperationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus( + janusGraphOperationStatus)); } } StorageOperationStatus getDerivedResult = derivedFrom.right().value(); @@ -2077,8 +2113,8 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe /* * @Override public PropertyOperation getPropertyOperation() { return this; } */ - public TitanOperationStatus fillPropertiesList(String uniqueId, NodeTypeEnum nodeType, Consumer> propertySetter) { - Either, TitanOperationStatus> findPropertiesRes = findPropertiesifExist(uniqueId, nodeType); + public JanusGraphOperationStatus fillPropertiesList(String uniqueId, NodeTypeEnum nodeType, Consumer> propertySetter) { + Either, JanusGraphOperationStatus> findPropertiesRes = findPropertiesifExist(uniqueId, nodeType); if (findPropertiesRes.isRight()) { return findPropertiesRes.right().value(); } @@ -2087,14 +2123,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe List propertiesAsList = properties.entrySet().stream().map(Entry::getValue).collect(Collectors.toList()); propertySetter.accept(propertiesAsList); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - Either, TitanOperationStatus> findPropertiesifExist(String uniqueId, NodeTypeEnum nodeType){ - Either, TitanOperationStatus> findPropertiesOfNode = this.findPropertiesOfNode(nodeType, uniqueId); + Either, JanusGraphOperationStatus> findPropertiesifExist(String uniqueId, NodeTypeEnum nodeType){ + Either, JanusGraphOperationStatus> findPropertiesOfNode = this.findPropertiesOfNode(nodeType, uniqueId); if (findPropertiesOfNode.isRight()) { log.debug("After looking for properties of vertex {}. status is {}", uniqueId, findPropertiesOfNode.right().value()); - if(findPropertiesOfNode.right().value() == TitanOperationStatus.NOT_FOUND) + if(findPropertiesOfNode.right().value() == JanusGraphOperationStatus.NOT_FOUND) return Either.left(Maps.newHashMap()); return findPropertiesOfNode; } @@ -2111,7 +2147,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * * @return */ - protected Either, TitanOperationStatus> addPropertiesToElementType(String uniqueId, NodeTypeEnum nodeType, Map propertiesMap) { + protected Either, JanusGraphOperationStatus> addPropertiesToElementType(String uniqueId, NodeTypeEnum nodeType, Map propertiesMap) { Map propertiesData = new HashMap<>(); @@ -2120,10 +2156,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe for (Entry propertyDefinitionEntry : propertiesMap.entrySet()) { String propertyName = propertyDefinitionEntry.getKey(); - Either addPropertyToNodeType = this.addPropertyToNodeType(propertyName, propertyDefinitionEntry.getValue(), nodeType, uniqueId); + Either addPropertyToNodeType = this.addPropertyToNodeType(propertyName, propertyDefinitionEntry.getValue(), nodeType, uniqueId); if (addPropertyToNodeType.isRight()) { - TitanOperationStatus operationStatus = addPropertyToNodeType.right().value(); + JanusGraphOperationStatus operationStatus = addPropertyToNodeType.right().value(); log.error("Failed to associate {} {} to property {} in graph. status is {}", nodeType.getName(), uniqueId, propertyName, operationStatus); return Either.right(operationStatus); } @@ -2136,7 +2172,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> addPropertiesToElementType(String uniqueId, NodeTypeEnum elementType, List properties) { + public Either, JanusGraphOperationStatus> addPropertiesToElementType(String uniqueId, NodeTypeEnum elementType, List properties) { Map propMap; if (properties == null) { @@ -2186,30 +2222,30 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if(MapUtils.isNotEmpty(newDescriptions)){ - TitanOperationStatus updatePropertiesStatus = updateDataTypePropertyDescriptions(oldDataTypeDefinition.getUniqueId(), newDescriptions); - if (updatePropertiesStatus != TitanOperationStatus.OK) { + JanusGraphOperationStatus updatePropertiesStatus = updateDataTypePropertyDescriptions(oldDataTypeDefinition.getUniqueId(), newDescriptions); + if (updatePropertiesStatus != JanusGraphOperationStatus.OK) { log.debug("#updateDataType - Failed to update the descriptions of the properties of the data type {}. Status is {}", oldDataTypeDefinition, updatePropertiesStatus); BeEcompErrorManager.getInstance().logBeFailedAddingNodeTypeError(UPDATE_DATA_TYPE, PROPERTY); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updatePropertiesStatus)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updatePropertiesStatus)); return result; } } - Either, TitanOperationStatus> addPropertiesToDataType = addPropertiesToDataType(oldDataTypeDefinition.getUniqueId(), propertiesToAdd); + Either, JanusGraphOperationStatus> addPropertiesToDataType = addPropertiesToDataType(oldDataTypeDefinition.getUniqueId(), propertiesToAdd); if (addPropertiesToDataType.isRight()) { log.debug("Failed to update data type {} to Graph. Status is {}", oldDataTypeDefinition, addPropertiesToDataType.right().value().name()); BeEcompErrorManager.getInstance().logBeFailedAddingNodeTypeError(UPDATE_DATA_TYPE, PROPERTY); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(addPropertiesToDataType.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertiesToDataType.right().value())); return result; } else { - Either dataTypeByUid = this.getDataTypeByUid(oldDataTypeDefinition.getUniqueId()); + Either dataTypeByUid = this.getDataTypeByUid(oldDataTypeDefinition.getUniqueId()); if (dataTypeByUid.isRight()) { - TitanOperationStatus status = addPropertiesToDataType.right().value(); + JanusGraphOperationStatus status = addPropertiesToDataType.right().value(); log.debug("Failed to get data type {} after update. Status is {}", oldDataTypeDefinition.getUniqueId(), status.name()); BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError(UPDATE_DATA_TYPE, PROPERTY, status.name()); - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)); } else { result = Either.left(dataTypeByUid.left().value()); } @@ -2221,10 +2257,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe if (!inTransaction) { if (result == null || result.isRight()) { log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -2364,14 +2400,15 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * @return */ public Either increaseAndGetObjInstancePropertyCounter(String instanceId, NodeTypeEnum nodeType) { - Either graphResult = titanGenericDao.getGraph(); + Either graphResult = janusGraphGenericDao.getGraph(); if (graphResult.isRight()) { - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graphResult.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graphResult.right().value())); } - Either vertexService = titanGenericDao.getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(nodeType), instanceId); + Either vertexService = janusGraphGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(nodeType), instanceId); if (vertexService.isRight()) { log.debug("failed to fetch vertex of resource instance for id = {}", instanceId); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(vertexService.right().value())); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexService.right().value())); } Vertex vertex = vertexService.left().value(); @@ -2388,12 +2425,13 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> validatePropertiesUniqueness(Map inheritedProperties, List properties) { - Either, TitanOperationStatus> result = Either.left(properties); + public Either, JanusGraphOperationStatus> validatePropertiesUniqueness(Map inheritedProperties, List properties) { + Either, JanusGraphOperationStatus> result = Either.left(properties); for (PropertyDefinition property : properties) { - TitanOperationStatus status = validatePropertyUniqueness(inheritedProperties, property); - if (status != TitanOperationStatus.OK) { + JanusGraphOperationStatus + status = validatePropertyUniqueness(inheritedProperties, property); + if (status != JanusGraphOperationStatus.OK) { result = Either.right(status); break; } @@ -2406,16 +2444,16 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe * Validates uniqueness of examined property by comparing it with properties in propertiesOfType * and updates if need type and inner type of the property. */ - private TitanOperationStatus validatePropertyUniqueness(Map inheritedProperties, PropertyDefinition property) { + private JanusGraphOperationStatus validatePropertyUniqueness(Map inheritedProperties, PropertyDefinition property) { String propertyName = property.getName(); String propertyType = property.getType(); - TitanOperationStatus result = TitanOperationStatus.OK; + JanusGraphOperationStatus result = JanusGraphOperationStatus.OK; if (inheritedProperties.containsKey(propertyName)) { PropertyDefinition defaultProperty = inheritedProperties.get(propertyName); if (typesMismatch(propertyType, defaultProperty.getType())) { log.error("#validatePropertyUniqueness - Property with name {} and different type already exists.", propertyName); - result = TitanOperationStatus.PROPERTY_NAME_ALREADY_EXISTS; + result = JanusGraphOperationStatus.PROPERTY_NAME_ALREADY_EXISTS; } else { property.setType(defaultProperty.getType()); String innerType = defaultProperty.getSchemaType(); @@ -2435,22 +2473,23 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } - public Either, TitanOperationStatus> getAllTypePropertiesFromAllDerivedFrom(String nextParentUid, - NodeTypeEnum nodeType, - Class clazz) { + public Either, JanusGraphOperationStatus> getAllTypePropertiesFromAllDerivedFrom(String nextParentUid, + NodeTypeEnum nodeType, + Class clazz) { Map allProperies = new HashMap<>(); return getTypePropertiesFromDerivedFromRecursively(nextParentUid, allProperies, nodeType, clazz); } - private Either, TitanOperationStatus> getTypePropertiesFromDerivedFromRecursively(String nextParentUid, - Map allProperies, - NodeTypeEnum nodeType, - Class clazz) { - TitanOperationStatus error; - Either>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), + private Either, JanusGraphOperationStatus> getTypePropertiesFromDerivedFromRecursively(String nextParentUid, + Map allProperies, + NodeTypeEnum nodeType, + Class clazz) { + JanusGraphOperationStatus error; + Either>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao + .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), nextParentUid, GraphEdgeLabels.DERIVED_FROM, nodeType, clazz); if (childrenNodes.isRight()) { - if (childrenNodes.right().value() != TitanOperationStatus.NOT_FOUND) { + if (childrenNodes.right().value() != JanusGraphOperationStatus.NOT_FOUND) { error = childrenNodes.right().value(); log.debug("#getTypePropertiesFromDerivedFromRecursively - Couldn't fetch derived from node with UID {}, error: {}", nextParentUid, error); return Either.right(error); @@ -2461,8 +2500,9 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe } } else { - Either, TitanOperationStatus> allPropertiesOfTypeRes = findPropertiesOfNode(nodeType, nextParentUid); - if (allPropertiesOfTypeRes.isRight() && !allPropertiesOfTypeRes.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + Either, JanusGraphOperationStatus> allPropertiesOfTypeRes = findPropertiesOfNode(nodeType, nextParentUid); + if (allPropertiesOfTypeRes.isRight() && !allPropertiesOfTypeRes.right().value().equals( + JanusGraphOperationStatus.NOT_FOUND)) { error = allPropertiesOfTypeRes.right().value(); log.error("#getTypePropertiesFromDerivedFromRecursively - Failed to retrieve properties for node with UID {} from graph. status is {}", nextParentUid, error); return Either.right(error); @@ -2476,10 +2516,11 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe return getTypePropertiesFromDerivedFromRecursively(childrenNodes.left().value().get(0).getLeft().getUniqueId(), allProperies, nodeType, clazz); } } - private TitanOperationStatus updateDataTypePropertyDescriptions(String uniqueId, Map newDescriptions) { + private JanusGraphOperationStatus updateDataTypePropertyDescriptions(String uniqueId, Map newDescriptions) { if (MapUtils.isNotEmpty(newDescriptions)) { - Either>, TitanOperationStatus> getDataTypePropertiesRes = titanGenericDao.getChildrenVertecies(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), uniqueId, GraphEdgeLabels.PROPERTY); + Either>, JanusGraphOperationStatus> getDataTypePropertiesRes = janusGraphGenericDao + .getChildrenVertecies(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), uniqueId, GraphEdgeLabels.PROPERTY); if(getDataTypePropertiesRes.isRight()){ log.debug("#updateDataTypePropertiesDescriptions - Failed to fetch the property verticies of the Data type {} ", uniqueId); @@ -2490,14 +2531,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe .forEach(pair -> setNewDescriptionToVertex(newDescriptions.get(getPropertyNameFromEdge(pair)), pair)); } - return TitanOperationStatus.OK; + return JanusGraphOperationStatus.OK; } - private TitanVertexProperty setNewDescriptionToVertex(String newDescription, ImmutablePair pair) { + private JanusGraphVertexProperty setNewDescriptionToVertex(String newDescription, ImmutablePair pair) { return pair.getLeft().property(GraphPropertiesDictionary.DESCRIPTION.getProperty(), newDescription); } - private String getPropertyNameFromEdge(ImmutablePair pair) { + private String getPropertyNameFromEdge(ImmutablePair pair) { return (String) pair.getRight().property(GraphPropertiesDictionary.NAME.getProperty()).value(); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperation.java index 13ad7a798c..0eaec1b805 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperation.java @@ -10,8 +10,8 @@ import org.apache.commons.collections.MapUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.RelationshipTypeDefinition; @@ -39,12 +39,12 @@ public class RelationshipTypeOperation extends AbstractOperation { private static final String FAILED_TO_FETCH_PROPERTIES_OF_RELATIONSHIP_TYPE = "Failed to fetch properties of " + "relationship type {}"; - public Either getRelationshipTypeByName(String name) { + public Either getRelationshipTypeByName(String name) { String uid = UniqueIdBuilder.buildRelationshipTypeUid(name); - Either result = getRelationshipTypeByUid(uid); + Either result = getRelationshipTypeByUid(uid); if (result.isRight()) { - TitanOperationStatus status = result.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = result.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { logger.error("Failed to get information on relationship type {} status is {}", name, status); } return Either.right(status); @@ -52,16 +52,16 @@ public class RelationshipTypeOperation extends AbstractOperation { return Either.left(result.left().value()); } - public Either getRelationshipTypeByUid(String uniqueId) { + public Either getRelationshipTypeByUid(String uniqueId) { - Either result; + Either result; - Either relationshipTypesRes = - titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType( + Either relationshipTypesRes = + janusGraphGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType( NodeTypeEnum.RelationshipType), uniqueId, RelationshipTypeData.class); if (relationshipTypesRes.isRight()) { - TitanOperationStatus status = relationshipTypesRes.right().value(); + JanusGraphOperationStatus status = relationshipTypesRes.right().value(); logger.debug("Relationship type {} cannot be found in graph. status is {}", uniqueId, status); return Either.right(status); } @@ -70,9 +70,9 @@ public class RelationshipTypeOperation extends AbstractOperation { RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition(relationshipTypeData.getRelationshipTypeDataDefinition()); - Either, TitanOperationStatus> propertiesStatus = + Either, JanusGraphOperationStatus> propertiesStatus = OperationUtils.fillProperties(uniqueId, propertyOperation, NodeTypeEnum.RelationshipType); - if (propertiesStatus.isRight() && propertiesStatus.right().value() != TitanOperationStatus.OK) { + if (propertiesStatus.isRight() && propertiesStatus.right().value() != JanusGraphOperationStatus.OK) { logger.error("Failed to fetch properties of relationship type {}", uniqueId); return Either.right(propertiesStatus.right().value()); } @@ -81,17 +81,17 @@ public class RelationshipTypeOperation extends AbstractOperation { relationshipTypeDefinition.setProperties(propertiesStatus.left().value()); } - Either, TitanOperationStatus> parentNode = titanGenericDao + Either, JanusGraphOperationStatus> parentNode = janusGraphGenericDao .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.RelationshipType), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.RelationshipType, RelationshipTypeData.class); logger.debug("After retrieving DERIVED_FROM node of {}. status is {}", uniqueId, parentNode); if (parentNode.isRight()) { - TitanOperationStatus titanOperationStatus = parentNode.right().value(); - if (titanOperationStatus != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value(); + if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) { logger.error("Failed to find the parent relationship of relationship type {}. status is {}", uniqueId, - titanOperationStatus); - result = Either.right(titanOperationStatus); + janusGraphOperationStatus); + result = Either.right(janusGraphOperationStatus); return result; } } else { @@ -107,27 +107,27 @@ public class RelationshipTypeOperation extends AbstractOperation { private Either validateUpdateProperties( RelationshipTypeDefinition relationshipTypeDefinition) { - TitanOperationStatus error = null; + JanusGraphOperationStatus error = null; if (MapUtils.isNotEmpty(relationshipTypeDefinition.getProperties()) && relationshipTypeDefinition.getDerivedFrom() != null) { - Either, TitanOperationStatus> allPropertiesRes = + Either, JanusGraphOperationStatus> allPropertiesRes = getAllRelationshipTypePropertiesFromAllDerivedFrom(relationshipTypeDefinition.getDerivedFrom()); - if (allPropertiesRes.isRight() && !TitanOperationStatus.NOT_FOUND.equals(allPropertiesRes.right().value())) { + if (allPropertiesRes.isRight() && !JanusGraphOperationStatus.NOT_FOUND.equals(allPropertiesRes.right().value())) { error = allPropertiesRes.right().value(); logger.debug("Couldn't fetch derived from property nodes for relationship type {}, error: {}", relationshipTypeDefinition.getType(), error); } - error = getTitanOperationStatus(relationshipTypeDefinition, error, allPropertiesRes); + error = getJanusGraphOperationStatus(relationshipTypeDefinition, error, allPropertiesRes); } if (error == null) { return Either.left(relationshipTypeDefinition); } - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error)); } - private TitanOperationStatus getTitanOperationStatus(RelationshipTypeDefinition relationshipTypeDefinition, - TitanOperationStatus error, - Either, TitanOperationStatus> allPropertiesRes) { + private JanusGraphOperationStatus getJanusGraphOperationStatus(RelationshipTypeDefinition relationshipTypeDefinition, + JanusGraphOperationStatus error, + Either, JanusGraphOperationStatus> allPropertiesRes) { if (error == null && !allPropertiesRes.left().value().isEmpty()) { Map derivedFromProperties = allPropertiesRes.left().value(); relationshipTypeDefinition.getProperties().entrySet().stream() @@ -136,7 +136,7 @@ public class RelationshipTypeOperation extends AbstractOperation { List properties = new ArrayList<>(relationshipTypeDefinition.getProperties().values()); - Either, TitanOperationStatus> validatePropertiesRes = + Either, JanusGraphOperationStatus> validatePropertiesRes = propertyOperation.validatePropertiesUniqueness(allPropertiesRes.left().value(), properties); if (validatePropertiesRes.isRight()) { error = validatePropertiesRes.right().value(); @@ -145,7 +145,7 @@ public class RelationshipTypeOperation extends AbstractOperation { return error; } - private Either, TitanOperationStatus> getAllRelationshipTypePropertiesFromAllDerivedFrom( + private Either, JanusGraphOperationStatus> getAllRelationshipTypePropertiesFromAllDerivedFrom( String firstParentType) { return propertyOperation.getAllTypePropertiesFromAllDerivedFrom(firstParentType, NodeTypeEnum.RelationshipType, RelationshipTypeData.class); @@ -185,10 +185,10 @@ public class RelationshipTypeOperation extends AbstractOperation { if (!inTransaction) { if (result == null || result.isRight()) { logger.error("#addRelationshipType - Going to execute rollback on graph."); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { logger.debug("#addRelationshipType - Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -200,15 +200,15 @@ public class RelationshipTypeOperation extends AbstractOperation { Either result; try { - Either ctResult = this.getRelationshipTypeByUid(uniqueId); + Either ctResult = this.getRelationshipTypeByUid(uniqueId); if (ctResult.isRight()) { - TitanOperationStatus status = ctResult.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = ctResult.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { logger.error("Failed to retrieve information on relationship type {}. status is {}", uniqueId, status); } - result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(ctResult.right().value())); + result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(ctResult.right().value())); return result; } @@ -218,7 +218,7 @@ public class RelationshipTypeOperation extends AbstractOperation { } finally { if (!inTransaction) { logger.debug("Going to execute commit on graph."); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -232,26 +232,26 @@ public class RelationshipTypeOperation extends AbstractOperation { RelationshipTypeData relationshipTypeData = buildRelationshipTypeData(relationshipTypeDefinition, ctUniqueId); logger.debug("Before adding relationship type to graph. relationshipTypeData = {}", relationshipTypeData); - Either createCTResult = - titanGenericDao.createNode(relationshipTypeData, RelationshipTypeData.class); + Either createCTResult = + janusGraphGenericDao.createNode(relationshipTypeData, RelationshipTypeData.class); logger.debug("After adding relationship type to graph. status is = {}", createCTResult); if (createCTResult.isRight()) { - TitanOperationStatus operationStatus = createCTResult.right().value(); + JanusGraphOperationStatus operationStatus = createCTResult.right().value(); logger.error("Failed to relationship type {} to graph. status is {}", relationshipTypeDefinition.getType(), operationStatus); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus)); } RelationshipTypeData resultCTD = createCTResult.left().value(); Map propertiesMap = relationshipTypeDefinition.getProperties(); - Either, TitanOperationStatus> addPropertiesToRelationshipType = propertyOperation + Either, JanusGraphOperationStatus> addPropertiesToRelationshipType = propertyOperation .addPropertiesToElementType(resultCTD.getUniqueId(), NodeTypeEnum.RelationshipType, propertiesMap); if (addPropertiesToRelationshipType.isRight()) { logger.error("Failed add properties {} to relationship {}", propertiesMap, relationshipTypeDefinition.getType()); return Either.right(DaoStatusConverter - .convertTitanStatusToStorageStatus(addPropertiesToRelationshipType.right().value())); + .convertJanusGraphStatusToStorageStatus(addPropertiesToRelationshipType.right().value())); } return addDerivedFromRelation(relationshipTypeDefinition, ctUniqueId) @@ -288,13 +288,13 @@ public class RelationshipTypeOperation extends AbstractOperation { + "{}", relationshipTypeDefinition.getType(), derivedFrom); return getRelationshipTypeByType(derivedFrom) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(derivedFromRelationship -> derivedFromOperation.addDerivedFromRelation(relationshipTypeUniqueId, derivedFromRelationship.getUniqueId(), NodeTypeEnum.RelationshipType)); } - private Either getRelationshipTypeByType( + private Either getRelationshipTypeByType( String relationshipType) { // Optimization: In case of Relationship Type its unique ID is the same as type return getRelationshipTypeByUid(relationshipType); @@ -312,9 +312,9 @@ public class RelationshipTypeOperation extends AbstractOperation { } finally { if (!inTransaction) { if (updateRelationshipEither == null || updateRelationshipEither.isRight()) { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @@ -325,10 +325,10 @@ public class RelationshipTypeOperation extends AbstractOperation { RelationshipTypeDefinition newRelationshipTypeDefinition, RelationshipTypeDefinition oldRelationshipTypeDefinition) { updateRelationshipTypeData(newRelationshipTypeDefinition, oldRelationshipTypeDefinition); - return titanGenericDao + return janusGraphGenericDao .updateNode(new RelationshipTypeData(newRelationshipTypeDefinition), RelationshipTypeData.class) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus) + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus) .left() .bind(updatedNode -> updateRelationshipTypeProperties(newRelationshipTypeDefinition.getUniqueId(), newRelationshipTypeDefinition.getProperties())) @@ -379,7 +379,7 @@ public class RelationshipTypeOperation extends AbstractOperation { return propertyOperation .addPropertiesToElementType(relationshipTypeId, NodeTypeEnum.RelationshipType, properties) .right() - .map(DaoStatusConverter::convertTitanStatusToStorageStatus); + .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } private StorageOperationStatus deleteDerivedFromRelationshipType(String relationshipTypeId, @@ -393,19 +393,20 @@ public class RelationshipTypeOperation extends AbstractOperation { .either(derivedFromNode -> derivedFromOperation .removeDerivedFromRelation(relationshipTypeId, derivedFromNode.getUniqueId(), NodeTypeEnum.RelationshipType), - DaoStatusConverter::convertTitanStatusToStorageStatus); + DaoStatusConverter::convertJanusGraphStatusToStorageStatus); } - public Either, TitanOperationStatus> getAllRelationshipTypes() { + public Either, JanusGraphOperationStatus> getAllRelationshipTypes() { Map relationshipTypeDefinitionMap = new HashMap<>(); - Either, TitanOperationStatus> result = Either.left(relationshipTypeDefinitionMap); + Either, JanusGraphOperationStatus> result = Either.left(relationshipTypeDefinitionMap); - Either, TitanOperationStatus> getAllRelationshipTypes = - titanGenericDao.getByCriteria(NodeTypeEnum.RelationshipType, null, RelationshipTypeData.class); + Either, JanusGraphOperationStatus> getAllRelationshipTypes = + janusGraphGenericDao + .getByCriteria(NodeTypeEnum.RelationshipType, null, RelationshipTypeData.class); if (getAllRelationshipTypes.isRight()) { - TitanOperationStatus status = getAllRelationshipTypes.right().value(); - if (status != TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus status = getAllRelationshipTypes.right().value(); + if (status != JanusGraphOperationStatus.NOT_FOUND) { return Either.right(status); } else { return result; @@ -417,8 +418,8 @@ public class RelationshipTypeOperation extends AbstractOperation { logger.trace("Number of relationship types to load is {}", list.size()); //Set properties - Either, TitanOperationStatus> status = - getMapTitanOperationStatusEither(relationshipTypeDefinitionMap, list); + Either, JanusGraphOperationStatus> status = + getMapJanusGraphOperationStatusEither(relationshipTypeDefinitionMap, list); if (status != null) { return status; } @@ -427,7 +428,7 @@ public class RelationshipTypeOperation extends AbstractOperation { return result; } - private Either, TitanOperationStatus> getMapTitanOperationStatusEither( + private Either, JanusGraphOperationStatus> getMapJanusGraphOperationStatusEither( Map relationshipTypeDefinitionMap, List list) { for (RelationshipTypeData relationshipTypeData : list) { @@ -435,12 +436,12 @@ public class RelationshipTypeOperation extends AbstractOperation { logger.trace("Going to fetch relationship type {}. uid is {}", relationshipTypeData.getRelationshipTypeDataDefinition().getType(), relationshipTypeData.getUniqueId()); - Either relationshipTypesByUid = + Either relationshipTypesByUid = getAndAddPropertiesANdDerivedFrom(relationshipTypeData.getUniqueId(), relationshipTypeDefinitionMap); if (relationshipTypesByUid.isRight()) { - TitanOperationStatus status = relationshipTypesByUid.right().value(); - if (status == TitanOperationStatus.NOT_FOUND) { - status = TitanOperationStatus.INVALID_ID; + JanusGraphOperationStatus status = relationshipTypesByUid.right().value(); + if (status == JanusGraphOperationStatus.NOT_FOUND) { + status = JanusGraphOperationStatus.INVALID_ID; } return Either.right(status); } @@ -448,18 +449,18 @@ public class RelationshipTypeOperation extends AbstractOperation { return null; } - private Either getAndAddPropertiesANdDerivedFrom( + private Either getAndAddPropertiesANdDerivedFrom( String uniqueId, Map relationshipTypeDefinitionMap) { if (relationshipTypeDefinitionMap.containsKey(uniqueId)) { return Either.left(relationshipTypeDefinitionMap.get(uniqueId)); } - Either relationshipTypesRes = - titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.RelationshipType), uniqueId, + Either relationshipTypesRes = + janusGraphGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.RelationshipType), uniqueId, RelationshipTypeData.class); if (relationshipTypesRes.isRight()) { - TitanOperationStatus status = relationshipTypesRes.right().value(); + JanusGraphOperationStatus status = relationshipTypesRes.right().value(); logger.debug(RELATIONSHIP_TYPE_CANNOT_BE_FOUND_IN_GRAPH_STATUS_IS, uniqueId, status); return Either.right(status); } @@ -468,9 +469,9 @@ public class RelationshipTypeOperation extends AbstractOperation { RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition(ctData.getRelationshipTypeDataDefinition()); - Either, TitanOperationStatus> propertiesStatus = + Either, JanusGraphOperationStatus> propertiesStatus = OperationUtils.fillProperties(uniqueId, propertyOperation, NodeTypeEnum.RelationshipType); - if (propertiesStatus.isRight() && propertiesStatus.right().value() != TitanOperationStatus.OK) { + if (propertiesStatus.isRight() && propertiesStatus.right().value() != JanusGraphOperationStatus.OK) { logger.error(FAILED_TO_FETCH_PROPERTIES_OF_RELATIONSHIP_TYPE, uniqueId); return Either.right(propertiesStatus.right().value()); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java index 72c370ffe6..bea9df9639 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java @@ -20,7 +20,7 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.BooleanUtils; import org.apache.tinkerpop.gremlin.structure.Direction; @@ -28,10 +28,10 @@ import org.apache.tinkerpop.gremlin.structure.Edge; import org.apache.tinkerpop.gremlin.structure.Vertex; import org.apache.tinkerpop.gremlin.structure.VertexProperty; import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.dao.utils.UserStatusEnum; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -52,11 +52,12 @@ import static org.apache.commons.collections.CollectionUtils.isEmpty; @Component("user-operation") public class UserAdminOperation implements IUserAdminOperation { - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; - public UserAdminOperation(@Qualifier("titan-generic-dao") TitanGenericDao titanGenericDao) { + public UserAdminOperation(@Qualifier("janusgraph-generic-dao") + JanusGraphGenericDao janusGraphGenericDao) { super(); - this.titanGenericDao = titanGenericDao; + this.janusGraphGenericDao = janusGraphGenericDao; } @@ -93,7 +94,7 @@ public class UserAdminOperation implements IUserAdminOperation { return resultWrapper.getInnerElement(); } finally { if (!inTransaction) { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } log.debug("getUserData - end"); } @@ -127,7 +128,8 @@ public class UserAdminOperation implements IUserAdminOperation { return; } id = id.toLowerCase(); - Either either = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); + Either either = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); if (either.isRight()) { resultWrapper.setInnerElement(getUserNotFoundError(id, either.right().value())); @@ -138,10 +140,10 @@ public class UserAdminOperation implements IUserAdminOperation { @Override public Either saveUserData(User user) { - Either result = null; + Either result = null; try { UserData userData = convertToUserData(user); - result = titanGenericDao.createNode(userData, UserData.class); + result = janusGraphGenericDao.createNode(userData, UserData.class); if (result.isRight()) { log.debug("Problem while saving User {}. Reason - {}", userData.getUserId(), result.right().value()); return Either.right(StorageOperationStatus.GENERAL_ERROR); @@ -153,21 +155,21 @@ public class UserAdminOperation implements IUserAdminOperation { if (result == null || result.isRight()) { log.error("saveUserData - Failed"); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("saveUserData - end"); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } } @Override public Either updateUserData(User user) { - Either result = null; + Either result = null; try { log.debug("updateUserData - start"); UserData userData = convertToUserData(user); - result = titanGenericDao.updateNode(userData, UserData.class); + result = janusGraphGenericDao.updateNode(userData, UserData.class); if (result.isRight()) { if (log.isDebugEnabled()) { log.debug("Problem while updating User {}. Reason - {}", userData.toString(), result.right().value()); @@ -181,10 +183,10 @@ public class UserAdminOperation implements IUserAdminOperation { if (result == null || result.isRight()) { log.error("updateUserData - Failed"); - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } else { log.debug("updateUserData - end"); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } @@ -206,10 +208,11 @@ public class UserAdminOperation implements IUserAdminOperation { @Override public Either deleteUserData(String id) { Either result; - Either eitherGet = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); + Either eitherGet = janusGraphGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); if (eitherGet.isRight()) { log.debug("Problem while retriving user with userId {}",id); - if (eitherGet.right().value() == TitanOperationStatus.NOT_FOUND) { + if (eitherGet.right().value() == JanusGraphOperationStatus.NOT_FOUND) { result = Either.right(ActionStatus.USER_NOT_FOUND); } else { result = Either.right(ActionStatus.GENERAL_ERROR); @@ -228,13 +231,14 @@ public class UserAdminOperation implements IUserAdminOperation { deleteUser(resultWrapper, userData); } } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } return resultWrapper.getInnerElement(); } private void deleteUser(Wrapper> resultWrapper, UserData userData) { - Either eitherDelete = titanGenericDao.deleteNode(userData, UserData.class); + Either eitherDelete = janusGraphGenericDao + .deleteNode(userData, UserData.class); if (eitherDelete.isRight()) { if (log.isDebugEnabled()) { log.debug("Problem while deleting User {}. Reason - {}", userData.toString(), eitherDelete.right().value()); @@ -249,7 +253,8 @@ public class UserAdminOperation implements IUserAdminOperation { private void validateUserHasNoConnections(Wrapper> resultWrapper, UserData userData) { if (resultWrapper.isEmpty()) { - Either, TitanOperationStatus> edgesForNode = titanGenericDao.getEdgesForNode(userData, Direction.BOTH); + Either, JanusGraphOperationStatus> edgesForNode = janusGraphGenericDao + .getEdgesForNode(userData, Direction.BOTH); if (edgesForNode.isRight()) { if (log.isDebugEnabled()) { log.debug("Problem while deleting User {}. Reason - {}", userData.getUserId(), edgesForNode.right().value()); @@ -266,21 +271,23 @@ public class UserAdminOperation implements IUserAdminOperation { public Either, StorageOperationStatus> getUserPendingTasksList(User user, Map properties) { - Either vertexUser = titanGenericDao.getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), user.getUserId()); + Either vertexUser = janusGraphGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), user.getUserId()); if (vertexUser.isRight()) { - TitanOperationStatus tos = vertexUser.right().value(); + JanusGraphOperationStatus tos = vertexUser.right().value(); log.debug("Failed to get User {} from graph while retrieving pending tasks. Reason - {}", user.getUserId(), tos); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(tos)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(tos)); } List pendingTasks = new ArrayList<>(); - Either, TitanOperationStatus> edges = titanGenericDao.getOutgoingEdgesByCriteria(vertexUser.left().value(), GraphEdgeLabels.STATE, properties); + Either, JanusGraphOperationStatus> edges = janusGraphGenericDao + .getOutgoingEdgesByCriteria(vertexUser.left().value(), GraphEdgeLabels.STATE, properties); if (edges.isRight() || edges.left().value() == null) { - TitanOperationStatus tos = edges.right().value(); - if (tos == TitanOperationStatus.NOT_FOUND) { + JanusGraphOperationStatus tos = edges.right().value(); + if (tos == JanusGraphOperationStatus.NOT_FOUND) { return Either.left(pendingTasks); } else { log.debug("Failed while retrieving pending tasks for user {} . Reason - {}", user.getUserId(), tos); - return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(tos)); + return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(tos)); } } for (Edge edge : edges.left().value()) { @@ -322,21 +329,22 @@ public class UserAdminOperation implements IUserAdminOperation { propertiesToMatch.put(GraphPropertiesDictionary.USER_STATUS.getProperty(), status); } - Either, TitanOperationStatus> userNodes = titanGenericDao.getByCriteria(NodeTypeEnum.User, propertiesToMatch, UserData.class); + Either, JanusGraphOperationStatus> userNodes = janusGraphGenericDao + .getByCriteria(NodeTypeEnum.User, propertiesToMatch, UserData.class); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); return convertToUsers(role, userNodes); } finally { - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } } - private Either, ActionStatus> convertToUsers(String role, Either, TitanOperationStatus> userNodes) { + private Either, ActionStatus> convertToUsers(String role, Either, JanusGraphOperationStatus> userNodes) { if (userNodes.isRight()) { - // in case of NOT_FOUND from Titan return empty list - TitanOperationStatus tos = userNodes.right().value(); - if (tos.equals(TitanOperationStatus.NOT_FOUND)) { + // in case of NOT_FOUND from JanusGraph return empty list + JanusGraphOperationStatus tos = userNodes.right().value(); + if (tos.equals(JanusGraphOperationStatus.NOT_FOUND)) { return Either.left(Collections.emptyList()); } else { log.error("Problem while getting all users with role {}. Reason - {}", role, tos); @@ -361,8 +369,8 @@ public class UserAdminOperation implements IUserAdminOperation { return result; } - private Either getUserNotFoundError(String uid, TitanOperationStatus status) { - if (status == TitanOperationStatus.NOT_FOUND) { + private Either getUserNotFoundError(String uid, JanusGraphOperationStatus status) { + if (status == JanusGraphOperationStatus.NOT_FOUND) { log.debug("User with userId {} not found", uid); return Either.right(ActionStatus.USER_NOT_FOUND); } else { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/utils/ComponentValidationUtils.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/utils/ComponentValidationUtils.java index d4cbc8d977..5c2212072c 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/utils/ComponentValidationUtils.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/utils/ComponentValidationUtils.java @@ -25,7 +25,7 @@ import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.LifecycleStateEnum; import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.common.log.wrappers.Logger; -- cgit 1.2.3-korg