Refactor data types cache

Avoids potential issue of data type cache changes by external parties,
by returning copies from the cache instead of the original.
Refactors the code for more clarity.

Change-Id: Ibb518bf638f2f4ee1f5e3869baaace374efb632a
Issue-ID: SDC-3569
Signed-off-by: André Schmid <andre.schmid@est.tech>

5 files changed, 204 insertions, 167 deletions

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
index 6c285802d2..b61aa5a4c2 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
@@ -37,17 +37,18 @@ public class DataTypeDefinition extends DataTypeDataDefinition {
     private List<PropertyConstraint> constraints;
     private List<PropertyDefinition> properties;
 
-    public DataTypeDefinition(DataTypeDataDefinition p) {
-        super(p);
+    public DataTypeDefinition(final DataTypeDataDefinition dataTypeDataDefinition) {
+        super(dataTypeDataDefinition);
     }
 
-    public DataTypeDefinition(DataTypeDefinition pd) {
-        this.setName(pd.getName());
-        this.setDerivedFrom(pd.getDerivedFrom());
-        this.setDerivedFromName(pd.getDerivedFromName());
-        this.setUniqueId(pd.getUniqueId());
-        this.setConstraints(pd.getConstraints());
-        this.setDescription(pd.getDescription());
+    public DataTypeDefinition(final DataTypeDefinition dataTypeDefinition) {
+        super(dataTypeDefinition);
+        this.setName(dataTypeDefinition.getName());
+        this.setDerivedFrom(dataTypeDefinition.getDerivedFrom());
+        this.setDerivedFromName(dataTypeDefinition.getDerivedFromName());
+        this.setUniqueId(dataTypeDefinition.getUniqueId());
+        this.setConstraints(dataTypeDefinition.getConstraints());
+        this.setDescription(dataTypeDefinition.getDescription());
     }
 
     public List<PropertyConstraint> safeGetConstraints() {
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 4c58285c12..d0a071909c 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
@@ -25,7 +25,7 @@ import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
 
 public interface ApplicationCache<T> {
 
-    public abstract Either<Map<String, T>, JanusGraphOperationStatus> getAll();
+    Either<Map<String, T>, JanusGraphOperationStatus> getAll();
 
-    public abstract Either<T, JanusGraphOperationStatus> get(String uniqueId);
+    Either<T, JanusGraphOperationStatus> 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 d6cc01b3ef..a1bafbc6f2 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
@@ -20,36 +20,33 @@
 package org.openecomp.sdc.be.model.cache;
 
 import fj.data.Either;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
+import java.util.Optional;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.stream.Collectors;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
-import javax.annotation.Resource;
+import lombok.AccessLevel;
 import lombok.Getter;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
-import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 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.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;
 import org.openecomp.sdc.be.resources.data.DataTypeData;
+import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
 import org.openecomp.sdc.common.log.wrappers.Logger;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
@@ -58,49 +55,68 @@ import org.springframework.stereotype.Component;
 public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefinition>, Runnable {
 
     private static final String APPLICATION_DATA_TYPES_CACHE = "ApplicationDataTypesCache";
-    private static final Logger log = Logger.getLogger(ApplicationDataTypeCache.class.getName());
-    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
-    private final Lock r = rwl.readLock();
-    private final Lock w = rwl.writeLock();
-    ScheduledFuture<?> scheduledFuture = null;
-    private Map<String, DataTypeDefinition> data = new HashMap<>();
-    private ScheduledExecutorService scheduledPollingService = Executors
-        .newScheduledThreadPool(1, new BasicThreadFactory.Builder().namingPattern("ApplicationDataTypeCacheThread-%d").build());
+    private static final Logger log = Logger.getLogger(ApplicationDataTypeCache.class);
+
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    private final PropertyOperation propertyOperation;
+    private final ApplicationEventPublisher applicationEventPublisher;
+    @Getter(AccessLevel.PACKAGE)
+    private final ScheduledExecutorService scheduledPollingService;
+    @Getter(AccessLevel.PACKAGE)
+    private ScheduledFuture<?> scheduledFuture = null;
+    private Map<String, DataTypeDefinition> dataTypesCacheMap = new HashMap<>();
     private int firstRunDelayInSec = 30;
     private int pollingIntervalInSec = 60;
-    @Resource
-    private PropertyOperation propertyOperation;
-    @Autowired
-    private ApplicationEventPublisher applicationEventPublisher;
+
+    public ApplicationDataTypeCache(final PropertyOperation propertyOperation, final ApplicationEventPublisher applicationEventPublisher) {
+        this.propertyOperation = propertyOperation;
+        this.applicationEventPublisher = applicationEventPublisher;
+        scheduledPollingService = Executors
+            .newScheduledThreadPool(1, new BasicThreadFactory.Builder().namingPattern("ApplicationDataTypeCacheThread-%d").build());
+    }
 
     @PostConstruct
-    public void init() {
-        ApplicationL1CacheConfig applicationL1CacheConfig = ConfigurationManager.getConfigurationManager().getConfiguration().getApplicationL1Cache();
-        if (applicationL1CacheConfig != null) {
-            if (applicationL1CacheConfig.getDatatypes() != null) {
-                ApplicationL1CacheInfo datatypesInfo = applicationL1CacheConfig.getDatatypes();
-                if (datatypesInfo.getEnabled()) {
-                    Integer intervalInSec = datatypesInfo.getPollIntervalInSec();
-                    if (intervalInSec != null) {
-                        pollingIntervalInSec = intervalInSec;
-                    }
-                    Integer firstRunDelay = datatypesInfo.getFirstRunDelay();
-                    if (firstRunDelay != null) {
-                        firstRunDelayInSec = firstRunDelay;
-                    }
-                    log.trace("ApplicationDataTypesCache polling interval is {} seconds.", pollingIntervalInSec);
-                    if (scheduledPollingService != null) {
-                        log.debug("Start ApplicationDataTypeCache polling task. polling interval {} seconds", pollingIntervalInSec);
-                        scheduledFuture = scheduledPollingService
-                            .scheduleAtFixedRate(this, firstRunDelayInSec, pollingIntervalInSec, TimeUnit.SECONDS);
-                    }
-                }
-            } else {
-                BeEcompErrorManager.getInstance().logInternalFlowError(APPLICATION_DATA_TYPES_CACHE, "Cache is disabled", ErrorSeverity.INFO);
-            }
-        } else {
-            BeEcompErrorManager.getInstance().logInternalFlowError(APPLICATION_DATA_TYPES_CACHE, "Cache is disabled", ErrorSeverity.INFO);
+    void init() {
+        final Optional<ApplicationL1CacheInfo> dataTypeCacheConfigOptional = getDataTypeCacheConfig();
+        if (dataTypeCacheConfigOptional.isEmpty()) {
+            BeEcompErrorManager.getInstance()
+                .logInternalFlowError(APPLICATION_DATA_TYPES_CACHE, "Data types cache is not configured and will be disabled", ErrorSeverity.INFO);
+            return;
+        }
+        final ApplicationL1CacheInfo dataTypesCacheInfo = dataTypeCacheConfigOptional.get();
+        if (!Boolean.TRUE.equals(dataTypesCacheInfo.getEnabled())) {
+            BeEcompErrorManager.getInstance().logInternalFlowError(APPLICATION_DATA_TYPES_CACHE, "Data types cache is disabled", ErrorSeverity.INFO);
+            return;
+        }
+        loadConfigurationValues(dataTypesCacheInfo);
+        if (scheduledPollingService != null) {
+            log.debug("Starting ApplicationDataTypeCache polling task. Initial delay {}s and polling interval {}s",
+                firstRunDelayInSec, pollingIntervalInSec);
+            scheduledFuture = scheduledPollingService
+                .scheduleAtFixedRate(this, firstRunDelayInSec, pollingIntervalInSec, TimeUnit.SECONDS);
+        }
+    }
+
+    private void loadConfigurationValues(final ApplicationL1CacheInfo dataTypesCacheInfo) {
+        final Integer firstRunDelay = dataTypesCacheInfo.getFirstRunDelay();
+        if (firstRunDelay != null) {
+            firstRunDelayInSec = firstRunDelay;
+        }
+        log.trace("ApplicationDataTypesCache initial delay configured to {} seconds.", firstRunDelayInSec);
+
+        final Integer intervalInSec = dataTypesCacheInfo.getPollIntervalInSec();
+        if (intervalInSec != null) {
+            pollingIntervalInSec = intervalInSec;
         }
+        log.trace("ApplicationDataTypesCache polling interval configured to {} seconds.", pollingIntervalInSec);
+    }
+
+    private Optional<ApplicationL1CacheInfo> getDataTypeCacheConfig() {
+        final var applicationL1CacheConfig = ConfigurationManager.getConfigurationManager().getConfiguration().getApplicationL1Cache();
+        if (applicationL1CacheConfig == null || applicationL1CacheConfig.getDatatypes() == null) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(applicationL1CacheConfig.getDatatypes());
     }
 
     @PreDestroy
@@ -147,138 +163,164 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
     @Override
     public Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAll() {
         try {
-            r.lock();
-            if (data == null || data.isEmpty()) {
+            readWriteLock.readLock().lock();
+            if (MapUtils.isEmpty(dataTypesCacheMap)) {
                 return getAllDataTypesFromGraph();
             }
-            return Either.left(data);
+            return Either.left(new HashMap<>(dataTypesCacheMap));
         } finally {
-            r.unlock();
+            readWriteLock.readLock().unlock();
         }
     }
 
     @Override
     public Either<DataTypeDefinition, JanusGraphOperationStatus> get(String uniqueId) {
         try {
-            r.lock();
-            if (data == null || data.isEmpty()) {
+            readWriteLock.readLock().lock();
+            if (MapUtils.isEmpty(dataTypesCacheMap)) {
+                return propertyOperation.getDataTypeByUid(uniqueId);
+            }
+
+            final Optional<DataTypeDefinition> dataTypeDefinition = dataTypesCacheMap.values().stream()
+                .filter(p -> p.getUniqueId().equals(uniqueId)).findFirst();
+            if (dataTypeDefinition.isEmpty()) {
                 return propertyOperation.getDataTypeByUid(uniqueId);
-            } else {
-                DataTypeDefinition dataTypeDefinition = data.values().stream().filter(p -> p.getUniqueId().equals(uniqueId)).findFirst().orElse(null);
-                if (dataTypeDefinition == null) {
-                    return propertyOperation.getDataTypeByUid(uniqueId);
-                } else {
-                    return Either.left(dataTypeDefinition);
-                }
             }
+            return Either.left(new DataTypeDefinition(dataTypeDefinition.get()));
         } finally {
-            r.unlock();
+            readWriteLock.readLock().unlock();
         }
     }
 
     @Override
     public void run() {
-        log.trace("run() method. polling db to fetch data types");
         try {
-            Long start = System.currentTimeMillis();
-            log.trace("Start fetching all data types from db");
-            Either<List<DataTypeData>, JanusGraphOperationStatus> allDataTypeNodes = propertyOperation.getAllDataTypeNodes();
-            Long end = System.currentTimeMillis();
-            log.trace("Finish fetching all data types from db. Took {} Milliseconds", (end - start));
-            if (allDataTypeNodes.isRight()) {
-                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);
-                }
-            } else {
-                List<DataTypeData> list = allDataTypeNodes.left().value();
-                if (list != null) {
-                    Map<String, ImmutablePair<Long, Long>> dataTypeNameToModificationTime = list.stream().collect(Collectors
-                        .toMap(p -> p.getDataTypeDataDefinition().getName(), p -> new ImmutablePair<>(p.getDataTypeDataDefinition().getCreationTime(),
-                            p.getDataTypeDataDefinition().getModificationTime())));
-                    Map<String, ImmutablePair<Long, Long>> currentDataTypeToModificationTime = new HashMap<>();
-                    try {
-                        r.lock();
-                        if (data != null) {
-                            currentDataTypeToModificationTime = data.values().stream().collect(Collectors
-                                .toMap(DataTypeDataDefinition::getName, p -> new ImmutablePair<>(p.getCreationTime(), p.getModificationTime())));
-                        }
-                    } finally {
-                        r.unlock();
-                    }
-                    boolean isChanged = compareDataTypes(dataTypeNameToModificationTime, currentDataTypeToModificationTime);
-                    if (isChanged) {
-                        replaceAllData();
-                    }
-                }
+            final long startTime = System.currentTimeMillis();
+            log.trace("Starting refresh data types cache job");
+            if (hasDataTypesChanged()) {
+                log.info("Detected changes in the data types, updating the data type cache.");
+                refreshDataTypesCache();
             }
-        } catch (Exception e) {
-            log.debug("unexpected error occured", e);
-            BeEcompErrorManager.getInstance()
-                .logInternalUnexpectedError(APPLICATION_DATA_TYPES_CACHE, "Failed to run refresh data types job", ErrorSeverity.INFO);
+            log.trace("Finished refresh data types cache job. Finished in {}ms", (System.currentTimeMillis() - startTime));
+        } catch (final Exception e) {
+            var errorMsg = "Failed to run refresh data types cache job";
+            log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, ApplicationDataTypeCache.class.getName(), errorMsg, e);
+            BeEcompErrorManager.getInstance().logInternalUnexpectedError(APPLICATION_DATA_TYPES_CACHE, errorMsg, ErrorSeverity.INFO);
         } finally {
             try {
                 propertyOperation.getJanusGraphGenericDao().commit();
-            } catch (Exception e) {
-                log.trace("Failed to commit ApplicationDataTypeCache", e);
+            } catch (final Exception e) {
+                log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, ApplicationDataTypeCache.class.getName(),
+                    "Failed to commit ApplicationDataTypeCache", e);
             }
         }
     }
 
-    private boolean compareDataTypes(Map<String, ImmutablePair<Long, Long>> dataTypeNameToModificationTime,
-                                     Map<String, ImmutablePair<Long, Long>> currentDataTypeToModificationTime) {
-        if (dataTypeNameToModificationTime.size() != currentDataTypeToModificationTime.size()) {
+    private boolean hasDataTypesChanged() {
+        final List<DataTypeData> dataTypeListFromDatabase = findAllDataTypesLazy();
+        final Map<String, DataTypeDefinition> dataTypesCacheCopyMap = copyDataTypeCache();
+
+        if (dataTypeListFromDatabase.size() != dataTypesCacheCopyMap.size()) {
+            log.debug("Total of cached data types '{}' differs from the actual '{}'", dataTypeListFromDatabase.size(),  dataTypesCacheCopyMap.size());
             return true;
-        } else {
-            Set<String> currentkeySet = currentDataTypeToModificationTime.keySet();
-            Set<String> keySet = dataTypeNameToModificationTime.keySet();
-            if (currentkeySet.containsAll(keySet)) {
-                for (Entry<String, ImmutablePair<Long, Long>> entry : dataTypeNameToModificationTime.entrySet()) {
-                    String dataTypeName = entry.getKey();
-                    ImmutablePair<Long, Long> creationAndModificationTimes = entry.getValue();
-                    long creationTime = creationAndModificationTimes.getLeft() == null ? 0 : creationAndModificationTimes.getLeft().longValue();
-                    long modificationTime = creationAndModificationTimes.getRight() == null ? 0 : creationAndModificationTimes.getRight().longValue();
-                    ImmutablePair<Long, Long> currentEntry = currentDataTypeToModificationTime.get(dataTypeName);
-                    long currentCreationTime = currentEntry.getLeft() == null ? 0 : currentEntry.getLeft().longValue();
-                    long currentModificationTime = currentEntry.getRight() == null ? 0 : currentEntry.getRight().longValue();
-                    if (creationTime > currentCreationTime || modificationTime > currentModificationTime) {
-                        log.debug("Datatype {} was updated. Creation Time  {} vs {}. Modification Time {} vs {}", dataTypeName, currentCreationTime,
-                            creationTime, currentModificationTime, modificationTime);
-                        return true;
-                    }
-                }
-            } else {
+        }
+
+        if (CollectionUtils.isEmpty(dataTypeListFromDatabase)) {
+            log.debug("Both data type cache and database are empty");
+            return false;
+        }
+
+        return hasDataTypesChanged(dataTypeListFromDatabase, dataTypesCacheCopyMap);
+    }
+
+    private boolean hasDataTypesChanged(final List<DataTypeData> dataTypeListFromDatabase, final Map<String, DataTypeDefinition> dataTypesCacheCopyMap) {
+        return dataTypeListFromDatabase.stream().map(DataTypeData::getDataTypeDataDefinition).anyMatch(actualDataTypeDefinition -> {
+            final String dataTypeName = actualDataTypeDefinition.getName();
+            final DataTypeDefinition cachedDataTypeDefinition = dataTypesCacheCopyMap.get(dataTypeName);
+            if (cachedDataTypeDefinition == null) {
+                log.debug("Datatype '{}' is not present in the cache. ", dataTypeName);
                 return true;
             }
+
+            final long cachedCreationTime = cachedDataTypeDefinition.getCreationTime() == null ? 0 : cachedDataTypeDefinition.getCreationTime();
+            final long actualCreationTime = actualDataTypeDefinition.getCreationTime() == null ? 0 : actualDataTypeDefinition.getCreationTime();
+            if (cachedCreationTime != actualCreationTime) {
+                log.debug("Datatype '{}' was updated. Cache/database creation time '{}'/'{}'.",
+                    dataTypeName, cachedCreationTime, actualCreationTime);
+                return true;
+            }
+            final long cachedModificationTime =
+                cachedDataTypeDefinition.getModificationTime() == null ? 0 : cachedDataTypeDefinition.getModificationTime();
+            final long actualModificationTime =
+                actualDataTypeDefinition.getModificationTime() == null ? 0 : actualDataTypeDefinition.getModificationTime();
+            if (cachedModificationTime != actualModificationTime) {
+                log.debug("Datatype '{}' was updated. Cache/database modification time '{}'/'{}'.",
+                    dataTypeName, cachedModificationTime, actualModificationTime);
+                return true;
+            }
+
+            return false;
+        });
+    }
+
+    private Map<String, DataTypeDefinition> copyDataTypeCache() {
+        try {
+            readWriteLock.readLock().lock();
+            return new HashMap<>(this.dataTypesCacheMap);
+        } finally {
+            readWriteLock.readLock().unlock();
         }
-        return false;
     }
 
-    private void replaceAllData() {
-        Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypes();
+    private void refreshDataTypesCache() {
+        final Map<String, DataTypeDefinition> dataTypesDefinitionMap = findAllDataTypesEager();
+        if (dataTypesDefinitionMap.isEmpty()) {
+            return;
+        }
+        try {
+            readWriteLock.writeLock().lock();
+            dataTypesCacheMap = dataTypesDefinitionMap;
+            onDataChangeEventEmit();
+            BeEcompErrorManager.getInstance()
+                .logInternalFlowError("ReplaceDataTypesCache", "Succeed to replace the data types cache", ErrorSeverity.INFO);
+        } finally {
+            readWriteLock.writeLock().unlock();
+        }
+    }
+
+    private Map<String, DataTypeDefinition> findAllDataTypesEager() {
+        log.trace("Fetching data types from database, eager mode");
+        final long startTime = System.currentTimeMillis();
+        final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypes();
+        log.trace("Finish fetching data types from database. Took {}ms", (System.currentTimeMillis() - startTime));
         if (allDataTypes.isRight()) {
-            JanusGraphOperationStatus status = allDataTypes.right().value();
-            log.debug("Failed to fetch all data types from db. Status is {}", status);
-        } else {
-            try {
-                w.lock();
-                data = allDataTypes.left().value();
-                // send notification on data types change
-                onDataChangeEventEmit(data);
-                BeEcompErrorManager.getInstance()
-                    .logInternalFlowError("ReplaceDataTypesCache", "Succeed to replace the data types cache", ErrorSeverity.INFO);
-            } finally {
-                w.unlock();
-            }
+            final JanusGraphOperationStatus status = allDataTypes.right().value();
+            var errorMsg= String.format("Failed to fetch data types from database. Status is %s", status);
+            log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, ApplicationDataTypeCache.class.getName(), errorMsg);
+            BeEcompErrorManager.getInstance().logInternalConnectionError(APPLICATION_DATA_TYPES_CACHE, errorMsg, ErrorSeverity.ERROR);
+            return Collections.emptyMap();
         }
+        return allDataTypes.left().value();
     }
 
-    private void onDataChangeEventEmit(Map<String, DataTypeDefinition> newData) {
-        log.trace("Cache data has changed, sending event to all listening for this change.");
-        DataTypesCacheChangedEvent dataTypesCacheChangedEvent = new DataTypesCacheChangedEvent(this, newData);
-        applicationEventPublisher.publishEvent(dataTypesCacheChangedEvent);
+    private List<DataTypeData> findAllDataTypesLazy() {
+        log.trace("Fetching data types from database, lazy mode");
+        final long startTime = System.currentTimeMillis();
+        final Either<List<DataTypeData>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypeNodes();
+        log.trace("Finish fetching data types from database. Took {}ms", (System.currentTimeMillis() - startTime));
+        if (allDataTypes.isRight()) {
+            final JanusGraphOperationStatus status = allDataTypes.right().value();
+            var errorMsg= String.format("Failed to fetch data types from database. Status is %s", status);
+            log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, ApplicationDataTypeCache.class.getName(), errorMsg);
+            BeEcompErrorManager.getInstance().logInternalConnectionError(APPLICATION_DATA_TYPES_CACHE, errorMsg, ErrorSeverity.ERROR);
+            return Collections.emptyList();
+        }
+        return allDataTypes.left().value();
+    }
+
+    private void onDataChangeEventEmit() {
+        log.trace("Data type cache has changed, sending DataTypesCacheChangedEvent.");
+        applicationEventPublisher.publishEvent(new DataTypesCacheChangedEvent(this, copyDataTypeCache()));
     }
 
     /**
@@ -287,11 +329,12 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
     public static class DataTypesCacheChangedEvent extends ApplicationEvent {
 
         @Getter
-        private Map<String, DataTypeDefinition> newData;
+        private final Map<String, DataTypeDefinition> newData;
 
-        public DataTypesCacheChangedEvent(Object source, Map<String, DataTypeDefinition> newData) {
+        public DataTypesCacheChangedEvent(final Object source, final Map<String, DataTypeDefinition> newData) {
             super(source);
             this.newData = newData;
         }
     }
+
 }
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 1592782bfa..db379f5915 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
@@ -42,7 +42,6 @@ import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.IComplexDefaultValue;
 import org.openecomp.sdc.be.model.PropertyConstraint;
-import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintDeserialiser;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
@@ -60,8 +59,6 @@ public abstract class AbstractOperation {
     @Autowired
     protected HealingJanusGraphGenericDao janusGraphGenericDao;
     protected Gson gson = new Gson();
-    @Autowired
-    protected ApplicationDataTypeCache applicationDataTypeCache;
     protected DataTypeValidatorConverter dataTypeValidatorConverter = DataTypeValidatorConverter.getInstance();
 
     public <ElementDefinition> JanusGraphOperationStatus findAllResourceElementsDefinitionRecursively(String resourceId,
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 790646754d..06323644b7 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
@@ -1562,14 +1562,10 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
     }
 
     public Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypeNodes() {
-        Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypes = janusGraphGenericDao
-            .getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class);
-        if (getAllDataTypes.isRight()) {
-            JanusGraphOperationStatus status = getAllDataTypes.right().value();
-            if (status == JanusGraphOperationStatus.NOT_FOUND) {
-                status = JanusGraphOperationStatus.OK;
-                return Either.right(status);
-            }
+        final Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypes =
+            janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class);
+        if (getAllDataTypes.isRight() && getAllDataTypes.right().value() == JanusGraphOperationStatus.NOT_FOUND) {
+            return Either.left(Collections.emptyList());
         }
         return getAllDataTypes;
     }