Enhancement activity in admin reconciliation for handling consecutive

triggering of same node

Change-Id: I4145f85faab738a4c81f0a2dd22d71890c70c133
Signed-off-by: eeiillu <suja.t@ericsson.com>

diff --git a/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/FrmReconciliationServiceImpl.java b/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/FrmReconciliationServiceImpl.java
index 2849df12e79ec3b5a7236de6d467c459fdd9086a..0af6532e9da3ea8998d7c558d9469cf61c0ca827 100644 (file)
--- a/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/FrmReconciliationServiceImpl.java
+++ b/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/FrmReconciliationServiceImpl.java
@@ -12,7 +12,6 @@ import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
-import javax.annotation.Nullable;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@@ -69,7 +68,7 @@ public class FrmReconciliationServiceImpl implements FrmReconciliationService {
         }
 
         @Override
-        public void onSuccess(@Nullable Boolean result) {
+        public void onSuccess(Boolean result) {
             if (result) {
                 ReconcileNodeOutput output = new ReconcileNodeOutputBuilder().setResult(result).build();
                 futureResult.set(RpcResultBuilder.success(output).build());

diff --git a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/ReconciliationServiceImpl.java b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/ReconciliationServiceImpl.java
index 5abf5e7d0b120b4f36c37f5c42dad8fed403b51b..33249f958a99253438a449169416edd3351c0f6a 100644 (file)
--- a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/ReconciliationServiceImpl.java
+++ b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/ReconciliationServiceImpl.java
@@ -8,12 +8,17 @@
 
 package org.opendaylight.openflowplugin.applications.southboundcli;
 
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State.COMPLETED;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State.FAILED;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State.INPROGRESS;
+
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import java.math.BigInteger;
-import java.time.LocalDateTime;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -21,11 +26,13 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.stream.Collectors;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.openflowplugin.applications.southboundcli.alarm.AlarmAgent;
 import org.opendaylight.openflowplugin.applications.southboundcli.util.OFNode;
 import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@@ -35,13 +42,19 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.ReconcileNodeInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.ReconcileNodeInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.ReconcileNodeOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconcileInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconcileOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconcileOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconciliationCounter;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconciliationService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.ReconciliationState;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.counter.ReconcileCounter;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.counter.ReconcileCounterBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.counter.ReconcileCounterKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.state.ReconciliationStateList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.state.ReconciliationStateListBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.state.ReconciliationStateListKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
@@ -52,12 +65,13 @@ import org.slf4j.LoggerFactory;
 public class ReconciliationServiceImpl implements ReconciliationService, AutoCloseable {
 
     private static final Logger LOG = LoggerFactory.getLogger(ReconciliationServiceImpl.class);
+
     private final DataBroker broker;
     private final FrmReconciliationService frmReconciliationService;
-    private final Long startCount = 1L;
     private final AlarmAgent alarmAgent;
-    private static final int THREAD_POOL_SIZE = 10;
-    private final ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
+    private final Long startCount = 1L;
+    private final int threadPoolSize = 10;
+    private final ExecutorService executor = Executors.newWorkStealingPool(threadPoolSize);
 
     public ReconciliationServiceImpl(final DataBroker broker, final FrmReconciliationService frmReconciliationService,
                                      final AlarmAgent alarmAgent) {
@@ -98,19 +112,45 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
                 return buildErrorResponse("Error executing command reconcile. "
                         + "Node(s) not found: " + String.join(", ", unresolvedNodes.toString()));
             }
+            List<BigInteger> inprogressNodes = new ArrayList<>();
             nodesToReconcile.parallelStream().forEach(nodeId -> {
-                alarmAgent.raiseNodeReconciliationAlarm(nodeId);
-                LOG.info("Executing reconciliation for node {}", nodeId);
-                NodeKey nodeKey = new NodeKey(new NodeId("openflow:" + nodeId));
-                ReconciliationTask reconcileTask = new ReconciliationTask(nodeId, nodeKey);
-                executor.execute(reconcileTask);
+                Optional<ReconciliationStateList> state = getReconciliationState(nodeId);
+                if (state.isPresent() && state.get().getState().equals(INPROGRESS)) {
+                    inprogressNodes.add(new BigInteger(String.valueOf(nodeId)));
+                } else {
+                    alarmAgent.raiseNodeReconciliationAlarm(nodeId);
+                    LOG.info("Executing reconciliation for node {}", nodeId);
+                    NodeKey nodeKey = new NodeKey(new NodeId("openflow:" + nodeId));
+                    ReconciliationTask reconcileTask = new ReconciliationTask(new BigInteger(String.valueOf(nodeId)),
+                            nodeKey);
+                    executor.execute(reconcileTask);
+                }
             });
+            ReconcileOutput reconcilingInProgress = new ReconcileOutputBuilder()
+                    .setInprogressNodes(inprogressNodes)
+                    .build();
+            result.set(RpcResultBuilder.success(reconcilingInProgress).build());
+            return result;
         } else {
             return buildErrorResponse("Error executing command reconcile. "
                     + "No node information is found for reconciliation");
         }
-        result.set(RpcResultBuilder.<ReconcileOutput>success().build());
-        return result;
+    }
+
+    private Optional<ReconciliationStateList> getReconciliationState(final Long nodeId) {
+        InstanceIdentifier<ReconciliationStateList> instanceIdentifier = InstanceIdentifier
+                .builder(ReconciliationState.class).child(ReconciliationStateList.class,
+                        new ReconciliationStateListKey(new BigInteger(String.valueOf(nodeId)))).build();
+        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
+        try {
+            return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
+
+        } catch (InterruptedException  | ExecutionException e) {
+            LOG.error("Exception while reading reconciliation state for {}", nodeId, e);
+        } finally {
+            tx.close();
+        }
+        return Optional.absent();
     }
 
     private ListenableFuture<RpcResult<ReconcileOutput>> buildErrorResponse(String msg) {
@@ -121,88 +161,106 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
         return result;
     }
 
-    public List<Long> getAllNodes() {
+    private List<Long> getAllNodes() {
         List<OFNode> nodeList = ShellUtil.getAllNodes(broker);
         List<Long> nodes = nodeList.stream().distinct().map(node -> node.getNodeId()).collect(Collectors.toList());
         return nodes;
     }
 
-    private void increaseReconcileCount(BigInteger nodeId, Boolean reconcileState) {
-        InstanceIdentifier<ReconcileCounter> instanceIdentifier = InstanceIdentifier
-                .builder(ReconciliationCounter.class).child(ReconcileCounter.class,
-                        new ReconcileCounterKey(nodeId)).build();
-        ReadWriteTransaction tx = broker.newReadWriteTransaction();
-        Optional<ReconcileCounter> optional = readReconcileCounterFromDS(tx, instanceIdentifier, nodeId);
-        ReconcileCounterBuilder counterBuilder = new ReconcileCounterBuilder()
-                .withKey(new ReconcileCounterKey(nodeId)).setNodeId(nodeId)
-                .setLastRequestTime(LocalDateTime.now().toString());
-        if (reconcileState) {
-            counterBuilder.setSuccessCount(startCount);
-            if (optional.isPresent()) {
-                ReconcileCounter counter = optional.get();
-                Long successCount = counter.getSuccessCount();
-                counterBuilder.setSuccessCount(++successCount);
-                LOG.debug("Reconcile Success count {} for the node: {} ", successCount, nodeId);
-            }
-        } else {
-            counterBuilder.setFailureCount(startCount);
-            if (optional.isPresent()) {
-                ReconcileCounter counter = optional.get();
-                Long failureCount = counter.getFailureCount();
-                counterBuilder.setFailureCount(++failureCount);
-                LOG.debug("Reconcile Failure count {} for the node: {} ", failureCount, nodeId);
-            }
-        }
-        try {
-            tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, counterBuilder.build(), true);
-            tx.submit().get();
-        } catch (InterruptedException | ExecutionException e) {
-            LOG.error("Exception while submitting counter {}", nodeId, e);
-        }
-    }
-
-    private Optional<ReconcileCounter> readReconcileCounterFromDS(ReadWriteTransaction tx,
-                InstanceIdentifier<ReconcileCounter> instanceIdentifier, BigInteger nodeId) {
-        try {
-            return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
-        } catch (InterruptedException | ExecutionException e) {
-            LOG.error("Exception while reading counter for node: {}", nodeId, e);
-        }
-        return Optional.absent();
-    }
-
     private final class ReconciliationTask implements Runnable {
+        private static final String DATE_AND_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
         private final NodeKey nodeKey;
-        private final Long nodeId;
+        private final BigInteger nodeId;
 
-        private ReconciliationTask(Long nodeId, NodeKey nodeKey) {
+        private ReconciliationTask(BigInteger nodeId, NodeKey nodeKey) {
             this.nodeId = nodeId;
             this.nodeKey = nodeKey;
         }
 
         @Override
         public void run() {
-            BigInteger node = new BigInteger(String.valueOf(nodeId));
             ReconcileNodeInput reconInput = new ReconcileNodeInputBuilder()
-                    .setNodeId(node).setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
+                    .setNodeId(nodeId).setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
                             .child(Node.class, nodeKey).build())).build();
+            updateReconciliationState(INPROGRESS);
             Future<RpcResult<ReconcileNodeOutput>> reconOutput = frmReconciliationService
                     .reconcileNode(reconInput);
             try {
                 RpcResult<ReconcileNodeOutput> rpcResult = reconOutput.get();
                 if (rpcResult.isSuccessful()) {
-                    increaseReconcileCount(node, true);
-                    LOG.info("Reconciliation successfully completed for node {}", nodeId);
+                    increaseReconcileCount(true);
+                    updateReconciliationState(COMPLETED);
+                    LOG.info("Reconciliation successfully completed for node {}", this.nodeId);
                 } else {
-                    increaseReconcileCount(node, false);
-                    LOG.error("Reconciliation failed for node {} with error {}", nodeId, rpcResult.getErrors());
+                    increaseReconcileCount(false);
+                    updateReconciliationState(FAILED);
+                    LOG.error("Reconciliation failed for node {} with error {}", this.nodeId, rpcResult.getErrors());
                 }
             } catch (ExecutionException | InterruptedException e) {
-                increaseReconcileCount(node, false);
-                LOG.error("Error occurred while invoking reconcile RPC for node {}", nodeId, e);
-            } finally {
-                alarmAgent.clearNodeReconciliationAlarm(nodeId);
+                increaseReconcileCount(false);
+                LOG.error("Error occurred while invoking reconcile RPC for node {}", this.nodeId, e);
+            }
+            finally {
+                alarmAgent.clearNodeReconciliationAlarm(nodeId.longValue());
+            }
+        }
+
+        private void increaseReconcileCount(final boolean isSuccess) {
+            final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATE_AND_TIME_FORMAT);
+            InstanceIdentifier<ReconcileCounter> instanceIdentifier = InstanceIdentifier
+                    .builder(ReconciliationCounter.class).child(ReconcileCounter.class,
+                            new ReconcileCounterKey(nodeId)).build();
+            ReadWriteTransaction tx = broker.newReadWriteTransaction();
+            Optional<ReconcileCounter> count = getReconciliationCount(tx, instanceIdentifier);
+            ReconcileCounterBuilder counterBuilder = new ReconcileCounterBuilder()
+                    .withKey(new ReconcileCounterKey(nodeId))
+                    .setLastRequestTime(new DateAndTime(simpleDateFormat.format(new Date())));
+
+            if (isSuccess) {
+                if (count.isPresent()) {
+                    Long successCount = count.get().getSuccessCount();
+                    counterBuilder.setSuccessCount(++successCount);
+                    LOG.debug("Reconcile success count {} for the node: {} ", successCount, nodeId);
+                } else {
+                    counterBuilder.setSuccessCount(startCount);
+                }
+            } else {
+                if (count.isPresent()) {
+                    Long failureCount = count.get().getFailureCount();
+                    counterBuilder.setFailureCount(++failureCount);
+                    LOG.debug("Reconcile failure count {} for the node: {} ", failureCount, nodeId);
+                } else {
+                    counterBuilder.setFailureCount(startCount);
+                }
             }
+            try {
+                tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, counterBuilder.build(), true);
+                tx.submit().get();
+            } catch (InterruptedException | ExecutionException e) {
+                LOG.error("Exception while submitting counter for {}", nodeId, e);
+            }
+        }
+
+        private Optional<ReconcileCounter> getReconciliationCount(ReadWriteTransaction tx,
+                                InstanceIdentifier<ReconcileCounter> instanceIdentifier) {
+            try {
+                return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
+            } catch (InterruptedException | ExecutionException e) {
+                LOG.error("Exception while reading counter for node: {}", nodeId, e);
+            }
+            return Optional.absent();
+        }
+
+        private void updateReconciliationState(State state) {
+            ReadWriteTransaction tx = broker.newReadWriteTransaction();
+            InstanceIdentifier<ReconciliationStateList> instanceIdentifier = InstanceIdentifier
+                    .builder(ReconciliationState.class).child(ReconciliationStateList.class,
+                            new ReconciliationStateListKey(nodeId)).build();
+            ReconciliationStateListBuilder stateBuilder = new ReconciliationStateListBuilder()
+                    .withKey(new ReconciliationStateListKey(nodeId))
+                    .setState(state);
+            tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, stateBuilder.build(), true);
+            tx.submit();
         }
     }
 }

diff --git a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/alarm/AlarmAgent.java b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/alarm/AlarmAgent.java
index dab304d91e2cd2219721bb117463dfc2b9cef0c5..b98d3f9a847e10a64994338ab1c3c0a673e3f600 100644 (file)
--- a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/alarm/AlarmAgent.java
+++ b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/alarm/AlarmAgent.java
@@ -97,7 +97,7 @@ public class AlarmAgent {
      *
      * @param nodeId Source of the alarm dpnId
      */
-    public void raiseNodeReconciliationAlarm(final long nodeId) {
+    public void raiseNodeReconciliationAlarm(final Long nodeId) {
         String alarmText = getAlarmText(nodeId,  " started reconciliation");
         String source = getSourceText(nodeId);
 
@@ -112,7 +112,7 @@ public class AlarmAgent {
      *
      * @param nodeId Source of the alarm dpnId
      */
-    public void clearNodeReconciliationAlarm(final long nodeId) {
+    public void clearNodeReconciliationAlarm(final Long nodeId) {
         String alarmText = getAlarmText(nodeId, " finished reconciliation");
         String source = getSourceText(nodeId);
 
@@ -127,7 +127,7 @@ public class AlarmAgent {
      * @param nodeId Source of the alarm nodeId
      * @param event reason for alarm invoke/clear
      */
-    private String getAlarmText(final long nodeId, final String event) {
+    private String getAlarmText(final Long nodeId, final String event) {
         return new StringBuffer("OF Switch ").append(nodeId).append(event).toString();
     }
 
@@ -136,7 +136,7 @@ public class AlarmAgent {
      *
      * @param nodeId Source of the alarm nodeId
      */
-    private String getSourceText(final long nodeId) {
+    private String getSourceText(final Long nodeId) {
         return new StringBuffer("Device=").append(nodeId).toString();
     }
 }

diff --git a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/Reconciliation.java b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/Reconciliation.java
index fcfe5e054db025587a213c6748f62dbad97eda83..02832b628bceb9d3149ee3b25e9f368a0fa3b8c1 100644 (file)
--- a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/Reconciliation.java
+++ b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/Reconciliation.java
@@ -10,6 +10,7 @@ package org.opendaylight.openflowplugin.applications.southboundcli.cli;
 
 import java.math.BigInteger;
 import java.util.ArrayList;
+import java.util.Formatter;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -54,7 +55,8 @@ public class Reconciliation extends OsgiCommandSupport {
         try {
             RpcResult<ReconcileOutput> rpcResult = rpcOutput.get();
             if (rpcResult.isSuccessful()) {
-                session.getConsole().println("Reconciliation triggered for the nodes");
+                session.getConsole().println("Reconciliation triggered for the node(s)");
+                printInProgressNodes(rpcResult.getResult());
             } else {
                 session.getConsole().println(rpcResult.getErrors().stream().findFirst().get().getMessage());
             }
@@ -63,4 +65,25 @@ public class Reconciliation extends OsgiCommandSupport {
         }
         return null;
     }
+
+    private void printInProgressNodes(ReconcileOutput reconcileOutput) {
+        List<BigInteger> inprogressNodes = reconcileOutput.getInprogressNodes();
+        if (inprogressNodes.size() > 0) {
+            StringBuilder stringBuilder = new StringBuilder();
+            final Formatter formatter = new Formatter(stringBuilder);
+            session.getConsole().println(getReconcileHeaderOutput());
+            session.getConsole().println("----------------------------------------------------");
+            for (BigInteger node : inprogressNodes) {
+                session.getConsole().println(formatter.format("%-15s %n",node).toString());
+                stringBuilder.setLength(0);
+            }
+        }
+    }
+
+    private String getReconcileHeaderOutput() {
+        final Formatter formatter = new Formatter();
+        String header = formatter.format("%-15s %n", "Reconciliation already InProgress for below node(s)").toString();
+        formatter.close();
+        return header;
+    }
 }
\ No newline at end of file

diff --git a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/ReconciliationCount.java b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/ReconciliationCount.java
index bb59716956c9c7ccec8381a6715f5ab52c7e4cfb..7a6270a1f23aff820f91cb0e657e7037a6cff7be 100644 (file)
--- a/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/ReconciliationCount.java
+++ b/applications/southbound-cli/src/main/java/org/opendaylight/openflowplugin/applications/southboundcli/cli/ReconciliationCount.java
@@ -30,17 +30,17 @@ public class ReconciliationCount extends OsgiCommandSupport {
     protected Object doExecute() throws Exception {
         List<ReconcileCounter> result = ShellUtil.getReconcileCount(dataBroker);
         if (result.isEmpty()) {
-            session.getConsole().println("Reconciliation is not yet completed or connected device not found.");
+            session.getConsole().println("Reconciliation count not yet available for openflow nodes.");
         } else {
             StringBuilder stringBuilder = new StringBuilder();
             final Formatter formatter = new Formatter(stringBuilder);
             session.getConsole().println(getReconcileCountHeaderOutput());
             session.getConsole().println("--------------------------------------------------------------------------"
-                    + "----------------------");
+                    + "---------------------------");
             for (ReconcileCounter reconcile : result) {
                 session.getConsole().println(formatter.format("%-15s %3s %-15s %9s %-20s %4s %-20s %n",
                         reconcile.getNodeId(), "", reconcile.getSuccessCount(), "", reconcile.getFailureCount(), "",
-                        reconcile.getLastRequestTime()).toString());
+                        reconcile.getLastRequestTime().getValue()).toString());
                 stringBuilder.setLength(0);
             }
             formatter.close();

diff --git a/applications/southbound-cli/src/main/yang/reconciliation.yang b/applications/southbound-cli/src/main/yang/reconciliation.yang
index 234b19023eaa28a189bf48e58585d4b7695dd62e..616e0a73a50dfce889030b3ca751939ab1baa56e 100644 (file)
--- a/applications/southbound-cli/src/main/yang/reconciliation.yang
+++ b/applications/southbound-cli/src/main/yang/reconciliation.yang
@@ -3,22 +3,24 @@ module reconciliation {
     namespace "urn:opendaylight:params:xml:ns:yang:openflowplugin:app:reconciliation:service";
     prefix reconciliation;
 
+    import ietf-yang-types {prefix yang; revision-date "2013-07-15";}
     revision "2018-02-27" {
         description "Initial revision for reconciliation";
     }
 
     container reconciliation-counter {
         description "Number of reconciliation triggered for openflow nodes";
+        config false;
         list reconcile-counter {
             key node-id;
+            leaf node-id {
+                type uint64;
+            }
             uses counter;
         }
     }
 
     grouping counter {
-        leaf node-id {
-            type uint64;
-        }
         leaf success-count {
             type uint32;
             default 0;
@@ -29,13 +31,35 @@ module reconciliation {
         }
         leaf last-request-time {
              description "Timestamp when reconciliation was last requested";
-             type string;
+             type yang:date-and-time;
         }
     }
 
+    container reconciliation-state {
+         description "Reconciliation state for the given openflow nodes";
+         config false;
+         list reconciliation-state-list {
+              key node-id;
+              leaf node-id {
+                   type uint64;
+              }
+              uses node-reconcile-state;
+         }
+    }
+
+    grouping node-reconcile-state {
+         leaf state {
+              description "Current state of the node reconciliation";
+              type enumeration {
+                   enum IN_PROGRESS;
+                   enum COMPLETED;
+                   enum FAILED;
+              }
+         }
+    }
+
     rpc reconcile {
-        description "Requests the execution of reconciliation between the controller and
-                     one or several or all Nodes";
+        description "Request the reconciliation for given device or set of devices to the controller.";
         input {
             leaf-list nodes {
                 description "List of nodes to be reconciled";
@@ -54,6 +78,11 @@ module reconciliation {
              leaf result {
                  type boolean;
              }
+
+             leaf-list inprogress-nodes {
+                 description "List of nodes currently reconciliation mode";
+                 type uint64;
+             }
         }
     }
-}
\ No newline at end of file
+}