Fixup Augmentable and Identifiable methods changing

[openflowplugin.git] / applications / forwardingrules-sync / src / main / java / org / opendaylight / openflowplugin / applications / frsync / impl / SimplifiedOperationalListener.java

diff --git a/applications/forwardingrules-sync/src/main/java/org/opendaylight/openflowplugin/applications/frsync/impl/SimplifiedOperationalListener.java b/applications/forwardingrules-sync/src/main/java/org/opendaylight/openflowplugin/applications/frsync/impl/SimplifiedOperationalListener.java
index 326b1debea1f67f245d70f680f4504a8fdaa5120..f7f51b4753f41a1bf76af834a868543fa3706938 100644 (file)
--- a/applications/forwardingrules-sync/src/main/java/org/opendaylight/openflowplugin/applications/frsync/impl/SimplifiedOperationalListener.java
+++ b/applications/forwardingrules-sync/src/main/java/org/opendaylight/openflowplugin/applications/frsync/impl/SimplifiedOperationalListener.java
@@ -15,9 +15,9 @@ import java.text.SimpleDateFormat;
 import java.util.Collection;
 import java.util.Date;
 import java.util.List;
+import java.util.Objects;
 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
@@ -73,37 +73,38 @@ public class SimplifiedOperationalListener extends AbstractFrmSyncListener<Node>
     /**
      * Update cache, register for device mastership when device connected and start reconciliation if device
      * is registered and actual modification is consistent.Skip the event otherwise.
-     * @throws InterruptedException from syncup
      */
+    @Override
     protected Optional<ListenableFuture<Boolean>> processNodeModification(
-            final DataTreeModification<Node> modification) throws InterruptedException {
+            final DataTreeModification<Node> modification) {
+        Optional<ListenableFuture<Boolean>> result;
         final NodeId nodeId = ModificationUtil.nodeId(modification);
-        updateCache(modification);
-
-        if (isAdd(modification) || isAddLogical(modification)) {
-            deviceMastershipManager.onDeviceConnected(nodeId);
-        }
+        final DataObjectModification<Node> nodeModification = modification.getRootNode();
 
-        if (reconciliationRegistry.isRegistered(nodeId) && isConsistentForReconcile(modification)) {
-            return reconciliation(modification);
-        } else {
-            return skipModification(modification);
-        }
-    }
-
-    /**
-     * Remove if delete. Update only if FlowCapableNode Augmentation modified.
-     * Unregister for device mastership.
-     * @param modification Datastore modification
-     */
-    private void updateCache(final DataTreeModification<Node> modification) {
-        NodeId nodeId = ModificationUtil.nodeId(modification);
-        if (isDelete(modification) || isDeleteLogical(modification)) {
+        if (isDelete(nodeModification) || isDeleteLogical(nodeModification)) {
             operationalSnapshot.updateCache(nodeId, Optional.absent());
             deviceMastershipManager.onDeviceDisconnected(nodeId);
-            return;
+            result = skipModification(modification);
+        } else {
+            operationalSnapshot.updateCache(nodeId, Optional.fromNullable(
+                    ModificationUtil.flowCapableNodeAfter(modification)));
+
+            final boolean isAdd = isAdd(nodeModification) || isAddLogical(nodeModification);
+
+            if (isAdd) {
+                deviceMastershipManager.onDeviceConnected(nodeId);
+            }
+
+            // if node is registered for reconcile we need consistent data from operational DS (skip partial
+            // collections) but we can accept first modification since all statistics are intentionally collected in
+            // one step on startup
+            if (reconciliationRegistry.isRegistered(nodeId) && (isAdd || isConsistentForReconcile(modification))) {
+                result = reconciliation(modification);
+            } else {
+                result = skipModification(modification);
+            }
         }
-        operationalSnapshot.updateCache(nodeId, Optional.fromNullable(ModificationUtil.flowCapableNodeAfter(modification)));
+        return result;
     }
 
     private Optional<ListenableFuture<Boolean>> skipModification(final DataTreeModification<Node> modification) {
@@ -116,33 +117,29 @@ public class SimplifiedOperationalListener extends AbstractFrmSyncListener<Node>
         return Optional.absent();
     }
 
-    /**
-     * ModificationType.DELETE.
-     */
-    private boolean isDelete(final DataTreeModification<Node> modification) {
-        return ModificationType.DELETE == modification.getRootNode().getModificationType();
+    private boolean isDelete(final DataObjectModification<Node> nodeModification) {
+        return Objects.nonNull(nodeModification.getDataBefore()) && Objects.isNull(nodeModification.getDataAfter());
     }
 
     /**
      * All connectors disappeared from operational store (logical delete).
      */
-    private boolean isDeleteLogical(final DataTreeModification<Node> modification) {
-        final DataObjectModification<Node> rootNode = modification.getRootNode();
-        return !safeConnectorsEmpty(rootNode.getDataBefore()) && safeConnectorsEmpty(rootNode.getDataAfter());
+    private boolean isDeleteLogical(final DataObjectModification<Node> nodeModification) {
+        return !safeConnectorsEmpty(nodeModification.getDataBefore())
+                && safeConnectorsEmpty(nodeModification.getDataAfter());
 
     }
 
-    private boolean isAdd(final DataTreeModification<Node> modification) {
-        final DataObjectModification<Node> rootNode = modification.getRootNode();
-        return rootNode.getDataBefore() == null && rootNode.getDataAfter() != null;
+    private boolean isAdd(final DataObjectModification<Node> nodeModification) {
+        return Objects.isNull(nodeModification.getDataBefore()) && Objects.nonNull(nodeModification.getDataAfter());
     }
 
     /**
      * All connectors appeared in operational store (logical add).
      */
-    private boolean isAddLogical(final DataTreeModification<Node> modification) {
-        final DataObjectModification<Node> rootNode = modification.getRootNode();
-        return safeConnectorsEmpty(rootNode.getDataBefore()) && !safeConnectorsEmpty(rootNode.getDataAfter());
+    private boolean isAddLogical(final DataObjectModification<Node> nodeModification) {
+        return safeConnectorsEmpty(nodeModification.getDataBefore())
+                && !safeConnectorsEmpty(nodeModification.getDataAfter());
     }
 
     /**
@@ -150,10 +147,8 @@ public class SimplifiedOperationalListener extends AbstractFrmSyncListener<Node>
      * configuration (coming from operational) should be calculated and sent to device.
      * @param modification from DS
      * @return optional syncup future
-     * @throws InterruptedException from syncup
      */
-    private Optional<ListenableFuture<Boolean>> reconciliation(final DataTreeModification<Node> modification)
-            throws InterruptedException {
+    private Optional<ListenableFuture<Boolean>> reconciliation(final DataTreeModification<Node> modification) {
         final NodeId nodeId = ModificationUtil.nodeId(modification);
         final Optional<FlowCapableNode> nodeConfiguration = configDao.loadByNodeId(nodeId);
 
@@ -173,10 +168,16 @@ public class SimplifiedOperationalListener extends AbstractFrmSyncListener<Node>
         }
     }
 
+    /**
+     * Check if modification is consistent for reconciliation. We need fresh data, which means that current statistics
+     * were collected after registration for reconcile and whole bunch of statistics was collected successfully.
+     * @param modification from DS
+     * @return status of modification
+     */
     private boolean isConsistentForReconcile(final DataTreeModification<Node> modification) {
         final NodeId nodeId = PathUtil.digNodeId(modification.getRootPath().getRootIdentifier());
         final FlowCapableStatisticsGatheringStatus gatheringStatus = modification.getRootNode().getDataAfter()
-                .getAugmentation(FlowCapableStatisticsGatheringStatus.class);
+                .augmentation(FlowCapableStatisticsGatheringStatus.class);
 
         if (gatheringStatus == null) {
             LOG.trace("Statistics gathering never started: {}", nodeId.getValue());