Bump MRI upstreams

[openflowplugin.git] / applications / southbound-cli / src / main / java / org / opendaylight / openflowplugin / applications / southboundcli / ReconciliationServiceImpl.java

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 c2839277ebb5c544a02a68c637b54c0ec463cb51..d20ba88a75700b86f3b9f8833dcb46d8da106623 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
@@ -12,15 +12,16 @@ import static org.opendaylight.openflowplugin.api.openflow.ReconciliationState.R
 import static org.opendaylight.openflowplugin.api.openflow.ReconciliationState.ReconciliationStatus.FAILED;
 import static org.opendaylight.openflowplugin.api.openflow.ReconciliationState.ReconciliationStatus.STARTED;
 
+import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
-import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -53,7 +54,8 @@ 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.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.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcError;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.opendaylight.yangtools.yang.common.Uint32;
@@ -69,9 +71,10 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
     private final AlarmAgent alarmAgent;
     private final NodeListener nodeListener;
     private final int threadPoolSize = 10;
-    private final ExecutorService executor = Executors.newWorkStealingPool(threadPoolSize);
     private final Map<String, ReconciliationState> reconciliationStates;
 
+    private ExecutorService executor = Executors.newWorkStealingPool(threadPoolSize);
+
     public ReconciliationServiceImpl(final DataBroker broker, final FrmReconciliationService frmReconciliationService,
                                      final AlarmAgent alarmAgent, final NodeListener nodeListener,
                                      final FlowGroupCacheManager flowGroupCacheManager) {
@@ -86,15 +89,16 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
     public void close() {
         if (executor != null) {
             executor.shutdownNow();
+            executor = null;
         }
     }
 
     @Override
-    public ListenableFuture<RpcResult<ReconcileOutput>> reconcile(ReconcileInput input) {
-        boolean reconcileAllNodes = input.isReconcileAllNodes();
-        List<Uint64> inputNodes = input.getNodes();
+    public ListenableFuture<RpcResult<ReconcileOutput>> reconcile(final ReconcileInput input) {
+        boolean reconcileAllNodes = input.getReconcileAllNodes();
+        Set<Uint64> inputNodes = input.getNodes();
         if (inputNodes == null) {
-            inputNodes = new ArrayList<>();
+            inputNodes = Set.of();
         }
         if (reconcileAllNodes && inputNodes.size() > 0) {
             return buildErrorResponse("Error executing command reconcile. "
@@ -114,7 +118,7 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
                 return buildErrorResponse("Error executing command reconcile. "
                         + "Node(s) not found: " + String.join(", ", unresolvedNodes.toString()));
             }
-            List<Uint64> inprogressNodes = new ArrayList<>();
+            ImmutableSet.Builder<Uint64> inprogressNodes = ImmutableSet.builder();
             nodesToReconcile.parallelStream().forEach(nodeId -> {
                 ReconciliationState state = getReconciliationState(nodeId);
                 if (state != null && state.getState().equals(STARTED)) {
@@ -128,7 +132,7 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
                 }
             });
             ReconcileOutput reconcilingInProgress = new ReconcileOutputBuilder()
-                    .setInprogressNodes(inprogressNodes)
+                    .setInprogressNodes(inprogressNodes.build())
                     .build();
             result.set(RpcResultBuilder.success(reconcilingInProgress).build());
             return result;
@@ -142,16 +146,16 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
         return reconciliationStates.get(nodeId.toString());
     }
 
-    private static ListenableFuture<RpcResult<ReconcileOutput>> buildErrorResponse(String msg) {
+    private static ListenableFuture<RpcResult<ReconcileOutput>> buildErrorResponse(final String msg) {
         LOG.error("Error {}", msg);
         return RpcResultBuilder.<ReconcileOutput>failed()
-                .withError(RpcError.ErrorType.PROTOCOL, "reconcile", msg)
+                .withError(ErrorType.PROTOCOL, new ErrorTag("reconcile"), msg)
                 .buildFuture();
     }
 
     private List<Long> getAllNodes() {
         List<OFNode> nodeList = ShellUtil.getAllNodes(nodeListener);
-        List<Long> nodes = nodeList.stream().distinct().map(node -> node.getNodeId()).collect(Collectors.toList());
+        List<Long> nodes = nodeList.stream().distinct().map(OFNode::getNodeId).collect(Collectors.toList());
         return nodes;
     }
 
@@ -160,7 +164,7 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
         private final NodeKey nodeKey;
         private final Uint64 nodeId;
 
-        private ReconciliationTask(Uint64 nodeId, NodeKey nodeKey) {
+        private ReconciliationTask(final Uint64 nodeId, final NodeKey nodeKey) {
             this.nodeId = nodeId;
             this.nodeKey = nodeKey;
         }
@@ -178,22 +182,23 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
                 if (rpcResult.isSuccessful()) {
                     increaseReconcileCount(true);
                     updateReconciliationState(COMPLETED);
-                    LOG.info("Reconciliation successfully completed for node {}", this.nodeId);
+                    LOG.info("Reconciliation successfully completed for node {}", nodeId);
                 } else {
                     increaseReconcileCount(false);
                     updateReconciliationState(FAILED);
-                    LOG.error("Reconciliation failed for node {} with error {}", this.nodeId, rpcResult.getErrors());
+                    LOG.error("Reconciliation failed for node {} with error {}", nodeId, rpcResult.getErrors());
                 }
             } catch (ExecutionException | InterruptedException e) {
                 increaseReconcileCount(false);
                 updateReconciliationState(FAILED);
-                LOG.error("Error occurred while invoking reconcile RPC for node {}", this.nodeId, e);
+                LOG.error("Error occurred while invoking reconcile RPC for node {}", nodeId, e);
             } finally {
                 alarmAgent.clearNodeReconciliationAlarm(nodeId.longValue());
             }
         }
 
         private void increaseReconcileCount(final boolean isSuccess) {
+            // FIXME: do not use SimpleDateFormat
             final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATE_AND_TIME_FORMAT);
             InstanceIdentifier<ReconcileCounter> instanceIdentifier = InstanceIdentifier
                     .builder(ReconciliationCounter.class).child(ReconcileCounter.class,
@@ -230,8 +235,8 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
             }
         }
 
-        private Optional<ReconcileCounter> getReconciliationCount(ReadWriteTransaction tx,
-                                                             InstanceIdentifier<ReconcileCounter> instanceIdentifier) {
+        private Optional<ReconcileCounter> getReconciliationCount(final ReadWriteTransaction tx,
+                final InstanceIdentifier<ReconcileCounter> instanceIdentifier) {
             try {
                 return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
             } catch (InterruptedException | ExecutionException e) {
@@ -240,8 +245,7 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo
             return Optional.empty();
         }
 
-
-        private void updateReconciliationState(ReconciliationState.ReconciliationStatus status) {
+        private void updateReconciliationState(final ReconciliationState.ReconciliationStatus status) {
             ReconciliationState state = new ReconciliationState(status, LocalDateTime.now());
             reconciliationStates.put(nodeId.toString(),state);
         }