Merge "Performance Improvement: Enhance state handler"

5 files changed, 173 insertions, 42 deletions

diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandler.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandler.java
index c428b1292..5ff2afa5e 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandler.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandler.java
@@ -20,6 +20,7 @@
 
 package org.onap.cps.ncmp.api.impl.event.lcm;
 
+import java.util.Map;
 import org.onap.cps.ncmp.api.impl.yangmodels.YangModelCmHandle;
 import org.onap.cps.ncmp.api.inventory.CmHandleState;
 import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle;
@@ -39,11 +40,19 @@ public interface LcmEventsCmHandleStateHandler {
     void updateCmHandleState(final YangModelCmHandle yangModelCmHandle, final CmHandleState targetCmHandleState);
 
     /**
+     * Updates the composite state of cmHandle based on cmHandleState in batch.
+     *
+     * @param cmHandleStatePerCmHandle Map of Yang Model Cm Handle and corresponding cm handle state.
+     */
+    void updateCmHandleStateBatch(final Map<YangModelCmHandle, CmHandleState> cmHandleStatePerCmHandle);
+
+    /**
      * Publish LCM Event.
      *
-     * @param targetNcmpServiceCmHandle   target NcmpServiceCmHandle
-     * @param existingNcmpServiceCmHandle existing NcmpServiceCmHandle
+     * @param targetNcmpServiceCmHandle  target NcmpServiceCmHandle
+     * @param currentNcmpServiceCmHandle current NcmpServiceCmHandle
      */
-    void publishLcmEvent(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
-            final NcmpServiceCmHandle existingNcmpServiceCmHandle);
+    void publishLcmEventAsynchronously(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
+            final NcmpServiceCmHandle currentNcmpServiceCmHandle);
+
 }
diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandlerImpl.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandlerImpl.java
index 7719e1b23..eba0389f2 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandlerImpl.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/event/lcm/LcmEventsCmHandleStateHandlerImpl.java
@@ -25,7 +25,15 @@ import static org.onap.cps.ncmp.api.inventory.CmHandleState.DELETED;
 import static org.onap.cps.ncmp.api.inventory.CmHandleState.LOCKED;
 import static org.onap.cps.ncmp.api.inventory.CmHandleState.READY;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import org.onap.cps.ncmp.api.impl.utils.YangDataConverter;
 import org.onap.cps.ncmp.api.impl.yangmodels.YangModelCmHandle;
@@ -48,26 +56,51 @@ public class LcmEventsCmHandleStateHandlerImpl implements LcmEventsCmHandleState
     private final LcmEventsService lcmEventsService;
 
     @Override
-    public void updateCmHandleState(final YangModelCmHandle yangModelCmHandle,
+    public void updateCmHandleState(final YangModelCmHandle updatedYangModelCmHandle,
             final CmHandleState targetCmHandleState) {
 
-        final CompositeState compositeState = yangModelCmHandle.getCompositeState();
+        final CompositeState compositeState = updatedYangModelCmHandle.getCompositeState();
 
-        if (compositeState != null && compositeState.getCmHandleState() == targetCmHandleState) {
-            log.debug("CmHandle with id : {} already in state : {}", yangModelCmHandle.getId(), targetCmHandleState);
+        if (isCompositeStateSame(compositeState, targetCmHandleState)) {
+            log.debug("CmHandle with id : {} already in state : {}", updatedYangModelCmHandle.getId(),
+                    targetCmHandleState);
         } else {
-            final NcmpServiceCmHandle existingNcmpServiceCmHandle =
-                    new NcmpServiceCmHandle(toNcmpServiceCmHandle(yangModelCmHandle));
-            updateToSpecifiedCmHandleState(yangModelCmHandle, targetCmHandleState);
-            final NcmpServiceCmHandle targetNcmpServiceCmHandle = toNcmpServiceCmHandle(yangModelCmHandle);
-            publishLcmEvent(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
+            final YangModelCmHandle currentYangModelCmHandle = YangModelCmHandle.deepCopyOf(updatedYangModelCmHandle);
+            updateToSpecifiedCmHandleState(updatedYangModelCmHandle, targetCmHandleState);
+            persistCmHandle(updatedYangModelCmHandle, currentYangModelCmHandle);
+            publishLcmEventAsynchronously(toNcmpServiceCmHandle(updatedYangModelCmHandle),
+                    toNcmpServiceCmHandle(currentYangModelCmHandle));
         }
+    }
 
+    @Override
+    public void updateCmHandleStateBatch(final Map<YangModelCmHandle, CmHandleState> cmHandleStatePerCmHandle) {
+        final Collection<CmHandleTransitionPair> cmHandleTransitionPairs =
+                prepareCmHandleTransitionBatch(cmHandleStatePerCmHandle);
+        persistCmHandleBatch(cmHandleTransitionPairs);
+        publishLcmEventBatchAsynchronously(cmHandleTransitionPairs);
     }
 
     @Async("notificationExecutor")
     @Override
-    public void publishLcmEvent(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
+    public void publishLcmEventAsynchronously(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
+            final NcmpServiceCmHandle currentNcmpServiceCmHandle) {
+        publishLcmEvent(targetNcmpServiceCmHandle, currentNcmpServiceCmHandle);
+    }
+
+    /**
+     * Publish LcmEvent in batches and in asynchronous manner.
+     *
+     * @param cmHandleTransitionPairs Pair of existing and modified cm handle represented as YangModelCmHandle
+     */
+    @Async("notificationExecutor")
+    public void publishLcmEventBatchAsynchronously(final Collection<CmHandleTransitionPair> cmHandleTransitionPairs) {
+        cmHandleTransitionPairs.forEach(cmHandleTransitionPair -> publishLcmEvent(
+                toNcmpServiceCmHandle(cmHandleTransitionPair.getTargetYangModelCmHandle()),
+                toNcmpServiceCmHandle(cmHandleTransitionPair.getCurrentYangModelCmHandle())));
+    }
+
+    private void publishLcmEvent(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
         final String cmHandleId = targetNcmpServiceCmHandle.getCmHandleId();
         final LcmEvent lcmEvent =
@@ -75,48 +108,119 @@ public class LcmEventsCmHandleStateHandlerImpl implements LcmEventsCmHandleState
         lcmEventsService.publishLcmEvent(cmHandleId, lcmEvent);
     }
 
+    private Collection<CmHandleTransitionPair> prepareCmHandleTransitionBatch(
+            final Map<YangModelCmHandle, CmHandleState> cmHandleStatePerCmHandle) {
+        final List<CmHandleTransitionPair> cmHandleTransitionPairs = new ArrayList<>(cmHandleStatePerCmHandle.size());
+        cmHandleStatePerCmHandle.forEach((yangModelCmHandle, targetCmHandleState) -> {
+
+            final CompositeState compositeState = yangModelCmHandle.getCompositeState();
+
+            if (isCompositeStateSame(compositeState, targetCmHandleState)) {
+                log.debug("CmHandle with id : {} already in state : {}", yangModelCmHandle.getId(),
+                        targetCmHandleState);
+            } else {
+                final CmHandleTransitionPair cmHandleTransitionPair = new CmHandleTransitionPair();
+                cmHandleTransitionPair.setCurrentYangModelCmHandle(YangModelCmHandle.deepCopyOf(yangModelCmHandle));
+                updateToSpecifiedCmHandleState(yangModelCmHandle, targetCmHandleState);
+                cmHandleTransitionPair.setTargetYangModelCmHandle(yangModelCmHandle);
+                cmHandleTransitionPairs.add(cmHandleTransitionPair);
+            }
+        });
+
+        return cmHandleTransitionPairs;
+    }
+
+
+    private void persistCmHandle(final YangModelCmHandle targetYangModelCmHandle,
+            final YangModelCmHandle currentYangModelCmHandle) {
+        if (isNew(currentYangModelCmHandle.getCompositeState(), targetYangModelCmHandle.getCompositeState())) {
+            log.debug("Registering a new cm handle {}", targetYangModelCmHandle.getId());
+            inventoryPersistence.saveCmHandle(targetYangModelCmHandle);
+        } else if (isDeleted(targetYangModelCmHandle.getCompositeState())) {
+            log.info("CmHandle with Id : {} is DELETED", targetYangModelCmHandle.getId());
+        } else {
+            inventoryPersistence.saveCmHandleState(targetYangModelCmHandle.getId(),
+                    targetYangModelCmHandle.getCompositeState());
+        }
+    }
+
+    private void persistCmHandleBatch(final Collection<CmHandleTransitionPair> cmHandleTransitionPairs) {
+
+        final List<YangModelCmHandle> newCmHandles = new ArrayList<>();
+        final Map<String, CompositeState> compositeStatePerCmHandleId = new LinkedHashMap<>();
+
+        cmHandleTransitionPairs.forEach(cmHandleTransitionPair -> {
+            if (isNew(cmHandleTransitionPair.getCurrentYangModelCmHandle().getCompositeState(),
+                    cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState())) {
+                newCmHandles.add(cmHandleTransitionPair.getTargetYangModelCmHandle());
+            } else if (!isDeleted(cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState())) {
+                compositeStatePerCmHandleId.put(cmHandleTransitionPair.getTargetYangModelCmHandle().getId(),
+                        cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState());
+            }
+        });
+
+        inventoryPersistence.saveCmHandleBatch(newCmHandles);
+        inventoryPersistence.saveCmHandleStateBatch(compositeStatePerCmHandleId);
+
+    }
+
+
     private void updateToSpecifiedCmHandleState(final YangModelCmHandle yangModelCmHandle,
             final CmHandleState targetCmHandleState) {
 
         if (READY == targetCmHandleState) {
-            CompositeStateUtils.setCompositeStateToReadyWithInitialDataStoreSyncState()
-                    .accept(yangModelCmHandle.getCompositeState());
-            inventoryPersistence.saveCmHandleState(yangModelCmHandle.getId(), yangModelCmHandle.getCompositeState());
+            setInitialStates(yangModelCmHandle);
         } else if (ADVISED == targetCmHandleState) {
             if (yangModelCmHandle.getCompositeState() == null) {
                 registerNewCmHandle(yangModelCmHandle);
             } else if (yangModelCmHandle.getCompositeState().getCmHandleState() == LOCKED) {
                 retryCmHandle(yangModelCmHandle);
             }
-        } else if (DELETED == targetCmHandleState) {
-            setCmHandleState(yangModelCmHandle, targetCmHandleState);
         } else {
-            updateAndSaveCmHandleState(yangModelCmHandle, targetCmHandleState);
+            setCmHandleState(yangModelCmHandle, targetCmHandleState);
         }
     }
 
+    private void setInitialStates(final YangModelCmHandle yangModelCmHandle) {
+        CompositeStateUtils.setInitialDataStoreSyncState().accept(yangModelCmHandle.getCompositeState());
+        CompositeStateUtils.setCompositeState(READY).accept(yangModelCmHandle.getCompositeState());
+    }
+
     private void retryCmHandle(final YangModelCmHandle yangModelCmHandle) {
         CompositeStateUtils.setCompositeStateForRetry().accept(yangModelCmHandle.getCompositeState());
-        inventoryPersistence.saveCmHandleState(yangModelCmHandle.getId(), yangModelCmHandle.getCompositeState());
     }
 
     private void registerNewCmHandle(final YangModelCmHandle yangModelCmHandle) {
         yangModelCmHandle.setCompositeState(new CompositeState());
         setCmHandleState(yangModelCmHandle, ADVISED);
-        inventoryPersistence.saveCmHandle(yangModelCmHandle);
-    }
-
-    private void updateAndSaveCmHandleState(final YangModelCmHandle yangModelCmHandle,
-            final CmHandleState targetCmHandleState) {
-        setCmHandleState(yangModelCmHandle, targetCmHandleState);
-        inventoryPersistence.saveCmHandleState(yangModelCmHandle.getId(), yangModelCmHandle.getCompositeState());
     }
 
     private void setCmHandleState(final YangModelCmHandle yangModelCmHandle, final CmHandleState targetCmHandleState) {
         CompositeStateUtils.setCompositeState(targetCmHandleState).accept(yangModelCmHandle.getCompositeState());
     }
 
+    private boolean isNew(final CompositeState existingCompositeState, final CompositeState targetCompositeState) {
+        return (existingCompositeState == null && targetCompositeState.getCmHandleState() == ADVISED);
+    }
+
+    private boolean isDeleted(final CompositeState targetCompositeState) {
+        return targetCompositeState.getCmHandleState() == DELETED;
+    }
+
+    private boolean isCompositeStateSame(final CompositeState compositeState, final CmHandleState targetCmHandleState) {
+        return (compositeState != null && compositeState.getCmHandleState() == targetCmHandleState);
+    }
+
     private NcmpServiceCmHandle toNcmpServiceCmHandle(final YangModelCmHandle yangModelCmHandle) {
         return YangDataConverter.convertYangModelCmHandleToNcmpServiceCmHandle(yangModelCmHandle);
     }
+
+    @Getter
+    @Setter
+    @NoArgsConstructor
+    static class CmHandleTransitionPair {
+
+        private YangModelCmHandle currentYangModelCmHandle;
+        private YangModelCmHandle targetYangModelCmHandle;
+    }
 }
diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/yangmodels/YangModelCmHandle.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/yangmodels/YangModelCmHandle.java
index 65e03f1f9..45e275422 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/yangmodels/YangModelCmHandle.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/yangmodels/YangModelCmHandle.java
@@ -69,6 +69,26 @@ public class YangModelCmHandle {
     private List<Property> publicProperties;
 
     /**
+     * Creates a deep copy of Yang Model Cm Handle.
+     *
+     * @param original Yang Model Cm Handle
+     * @return instance of yangModelCmHandle
+     */
+    public static YangModelCmHandle deepCopyOf(final YangModelCmHandle original) {
+        final YangModelCmHandle copy = new YangModelCmHandle();
+        copy.id = original.getId();
+        copy.dmiServiceName = original.getDmiServiceName();
+        copy.dmiDataServiceName = original.getDmiDataServiceName();
+        copy.dmiModelServiceName = original.getDmiModelServiceName();
+        copy.compositeState =
+                original.getCompositeState() == null ? null : new CompositeState(original.getCompositeState());
+        copy.dmiProperties = original.getDmiProperties() == null ? null : new ArrayList<>(original.getDmiProperties());
+        copy.publicProperties =
+                original.getPublicProperties() == null ? null : new ArrayList<>(original.getPublicProperties());
+        return copy;
+    }
+
+    /**
      * Create a yangModelCmHandle.
      *
      * @param dmiServiceName      dmi service name
diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/CompositeStateUtils.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/CompositeStateUtils.java
index 6fabc9300..cff1000fe 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/CompositeStateUtils.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/CompositeStateUtils.java
@@ -45,15 +45,14 @@ public class CompositeStateUtils {
     }
 
     /**
-     * Sets the cmHandleState to READY and operational datastore sync state based on the global flag.
+     * Set the Operational datastore sync state based on the global flag.
      *
      * @return Updated CompositeState
      */
-    public static Consumer<CompositeState> setCompositeStateToReadyWithInitialDataStoreSyncState() {
+    public static Consumer<CompositeState> setInitialDataStoreSyncState() {
+
         return compositeState -> {
             compositeState.setDataSyncEnabled(false);
-            compositeState.setLastUpdateTimeNow();
-            compositeState.setCmHandleState(CmHandleState.READY);
             final CompositeState.Operational operational =
                     getInitialDataStoreSyncState(compositeState.getDataSyncEnabled());
             final CompositeState.DataStores dataStores =
@@ -66,15 +65,15 @@ public class CompositeStateUtils {
      * Set the data sync enabled flag, along with the data store sync state based on this flag.
      *
      * @param dataSyncEnabled data sync enabled flag
-     * @param compositeState cm handle composite state
+     * @param compositeState  cm handle composite state
      */
     public static void setDataSyncEnabledFlagWithDataSyncState(final boolean dataSyncEnabled,
-                                                               final CompositeState compositeState) {
+            final CompositeState compositeState) {
         compositeState.setDataSyncEnabled(dataSyncEnabled);
         compositeState.setLastUpdateTimeNow();
         final CompositeState.Operational operational = getInitialDataStoreSyncState(dataSyncEnabled);
         final CompositeState.DataStores dataStores =
-            CompositeState.DataStores.builder().operationalDataStore(operational).build();
+                CompositeState.DataStores.builder().operationalDataStore(operational).build();
         compositeState.setDataStores(dataStores);
     }
 
diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/InventoryPersistence.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/InventoryPersistence.java
index 7a7ef6666..9174dc7a7 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/InventoryPersistence.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/inventory/InventoryPersistence.java
@@ -103,16 +103,15 @@ public class InventoryPersistence {
     /**
      * Save all cm handles states in batch.
      *
-     * @param cmHandleStates contains cm handle id and updated state
+     * @param cmHandleStatePerCmHandleId contains cm handle id and updated state
      */
-    public void saveCmHandleStates(final Map<String, CompositeState> cmHandleStates) {
+    public void saveCmHandleStateBatch(final Map<String, CompositeState> cmHandleStatePerCmHandleId) {
         final Map<String, String> cmHandlesJsonDataMap = new HashMap<>();
-        cmHandleStates.entrySet().stream().forEach(cmHandleEntry ->
-            cmHandlesJsonDataMap.put(String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleEntry.getKey()),
-                String.format("{\"state\":%s}",
-                    jsonObjectMapper.asJsonString(cmHandleEntry.getValue()))));
+        cmHandleStatePerCmHandleId.forEach((cmHandleId, compositeState) -> cmHandlesJsonDataMap.put(
+                String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleId),
+                String.format("{\"state\":%s}", jsonObjectMapper.asJsonString(compositeState))));
         cpsDataService.updateDataNodesAndDescendants(NCMP_DATASPACE_NAME, NCMP_DMI_REGISTRY_ANCHOR,
-            cmHandlesJsonDataMap, OffsetDateTime.now());
+                cmHandlesJsonDataMap, OffsetDateTime.now());
     }
 
     /**