X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=applications%2Fsouthbound-cli%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fapplications%2Fsouthboundcli%2FReconciliationServiceImpl.java;h=d20ba88a75700b86f3b9f8833dcb46d8da106623;hb=777c94332871b8c34f56f7f2010de1536cb759ba;hp=d1a0ede63e260891140ebdf20e3250516433d732;hpb=b5c701276828fdb5bc7e9c5d88b427541b4a6250;p=openflowplugin.git 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 d1a0ede63e..d20ba88a75 100644 --- 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 @@ -5,31 +5,33 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.openflowplugin.applications.southboundcli; import static java.util.Objects.requireNonNull; -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 static org.opendaylight.openflowplugin.api.openflow.ReconciliationState.ReconciliationStatus.COMPLETED; +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.math.BigInteger; import java.text.SimpleDateFormat; -import java.util.ArrayList; +import java.time.LocalDateTime; 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; import java.util.concurrent.Future; import java.util.stream.Collectors; import org.opendaylight.mdsal.binding.api.DataBroker; -import org.opendaylight.mdsal.binding.api.ReadTransaction; import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.openflowplugin.api.openflow.FlowGroupCacheManager; +import org.opendaylight.openflowplugin.api.openflow.ReconciliationState; import org.opendaylight.openflowplugin.applications.southboundcli.alarm.AlarmAgent; import org.opendaylight.openflowplugin.applications.southboundcli.util.OFNode; import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil; @@ -43,60 +45,60 @@ 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.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; import org.opendaylight.yangtools.yang.common.Uint64; import org.slf4j.Logger; 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 AlarmAgent alarmAgent; private final NodeListener nodeListener; - private final Long startCount = 1L; private final int threadPoolSize = 10; - private final ExecutorService executor = Executors.newWorkStealingPool(threadPoolSize); + private final Map reconciliationStates; + + private ExecutorService executor = Executors.newWorkStealingPool(threadPoolSize); public ReconciliationServiceImpl(final DataBroker broker, final FrmReconciliationService frmReconciliationService, - final AlarmAgent alarmAgent, final NodeListener nodeListener) { + final AlarmAgent alarmAgent, final NodeListener nodeListener, + final FlowGroupCacheManager flowGroupCacheManager) { this.broker = broker; this.frmReconciliationService = frmReconciliationService; this.alarmAgent = alarmAgent; this.nodeListener = requireNonNull(nodeListener, "NodeListener cannot be null!"); + reconciliationStates = flowGroupCacheManager.getReconciliationStates(); } @Override public void close() { if (executor != null) { executor.shutdownNow(); + executor = null; } } @Override - public ListenableFuture> reconcile(ReconcileInput input) { - boolean reconcileAllNodes = input.isReconcileAllNodes(); - List inputNodes = input.getNodes(); + public ListenableFuture> reconcile(final ReconcileInput input) { + boolean reconcileAllNodes = input.getReconcileAllNodes(); + Set inputNodes = input.getNodes(); if (inputNodes == null) { - inputNodes = new ArrayList<>(); + inputNodes = Set.of(); } if (reconcileAllNodes && inputNodes.size() > 0) { return buildErrorResponse("Error executing command reconcile. " @@ -116,22 +118,21 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo return buildErrorResponse("Error executing command reconcile. " + "Node(s) not found: " + String.join(", ", unresolvedNodes.toString())); } - List inprogressNodes = new ArrayList<>(); + ImmutableSet.Builder inprogressNodes = ImmutableSet.builder(); nodesToReconcile.parallelStream().forEach(nodeId -> { - Optional state = getReconciliationState(nodeId); - if (state.isPresent() && state.get().getState().equals(INPROGRESS)) { + ReconciliationState state = getReconciliationState(nodeId); + if (state != null && state.getState().equals(STARTED)) { inprogressNodes.add(Uint64.valueOf(nodeId)); } else { alarmAgent.raiseNodeReconciliationAlarm(nodeId); - LOG.info("Executing reconciliation for node {}", nodeId); + LOG.info("Executing reconciliation for node {} with state ", nodeId); NodeKey nodeKey = new NodeKey(new NodeId("openflow:" + nodeId)); - ReconciliationTask reconcileTask = new ReconciliationTask(new BigInteger(String.valueOf(nodeId)), - nodeKey); + ReconciliationTask reconcileTask = new ReconciliationTask(Uint64.valueOf(nodeId), nodeKey); executor.execute(reconcileTask); } }); ReconcileOutput reconcilingInProgress = new ReconcileOutputBuilder() - .setInprogressNodes(inprogressNodes) + .setInprogressNodes(inprogressNodes.build()) .build(); result.set(RpcResultBuilder.success(reconcilingInProgress).build()); return result; @@ -141,39 +142,29 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo } } - private Optional getReconciliationState(final Long nodeId) { - InstanceIdentifier instanceIdentifier = InstanceIdentifier - .builder(ReconciliationState.class).child(ReconciliationStateList.class, - new ReconciliationStateListKey(new BigInteger(String.valueOf(nodeId)))).build(); - try (ReadTransaction tx = broker.newReadOnlyTransaction()) { - return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get(); - - } catch (InterruptedException | ExecutionException e) { - LOG.error("Exception while reading reconciliation state for {}", nodeId, e); - } - return Optional.empty(); + private ReconciliationState getReconciliationState(final Long nodeId) { + return reconciliationStates.get(nodeId.toString()); } - private ListenableFuture> buildErrorResponse(String msg) { - SettableFuture> result = SettableFuture.create(); + private static ListenableFuture> buildErrorResponse(final String msg) { LOG.error("Error {}", msg); - RpcError error = RpcResultBuilder.newError(RpcError.ErrorType.PROTOCOL, "reconcile", msg); - result.set(RpcResultBuilder.failed().withRpcError(error).build()); - return result; + return RpcResultBuilder.failed() + .withError(ErrorType.PROTOCOL, new ErrorTag("reconcile"), msg) + .buildFuture(); } private List getAllNodes() { List nodeList = ShellUtil.getAllNodes(nodeListener); - List nodes = nodeList.stream().distinct().map(node -> node.getNodeId()).collect(Collectors.toList()); + List nodes = nodeList.stream().distinct().map(OFNode::getNodeId).collect(Collectors.toList()); return nodes; } 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 BigInteger nodeId; + private final Uint64 nodeId; - private ReconciliationTask(BigInteger nodeId, NodeKey nodeKey) { + private ReconciliationTask(final Uint64 nodeId, final NodeKey nodeKey) { this.nodeId = nodeId; this.nodeKey = nodeKey; } @@ -183,7 +174,7 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo ReconcileNodeInput reconInput = new ReconcileNodeInputBuilder() .setNodeId(nodeId).setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class) .child(Node.class, nodeKey).build())).build(); - updateReconciliationState(INPROGRESS); + updateReconciliationState(STARTED); Future> reconOutput = frmReconciliationService .reconcileNode(reconInput); try { @@ -191,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 instanceIdentifier = InstanceIdentifier .builder(ReconciliationCounter.class).child(ReconcileCounter.class, @@ -220,30 +212,31 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo if (isSuccess) { if (count.isPresent()) { long successCount = count.get().getSuccessCount().toJava(); - counterBuilder.setSuccessCount(++successCount); + counterBuilder.setSuccessCount(Uint32.valueOf(++successCount)); LOG.debug("Reconcile success count {} for the node: {} ", successCount, nodeId); } else { - counterBuilder.setSuccessCount(startCount); + counterBuilder.setSuccessCount(Uint32.ONE); } } else { if (count.isPresent()) { long failureCount = count.get().getFailureCount().toJava(); - counterBuilder.setFailureCount(++failureCount); + counterBuilder.setFailureCount(Uint32.valueOf(++failureCount)); LOG.debug("Reconcile failure count {} for the node: {} ", failureCount, nodeId); } else { - counterBuilder.setFailureCount(startCount); + counterBuilder.setFailureCount(Uint32.ONE); } } try { - tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, counterBuilder.build(), true); + tx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, + counterBuilder.build()); tx.commit().get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Exception while submitting counter for {}", nodeId, e); } } - private Optional getReconciliationCount(ReadWriteTransaction tx, - InstanceIdentifier instanceIdentifier) { + private Optional getReconciliationCount(final ReadWriteTransaction tx, + final InstanceIdentifier instanceIdentifier) { try { return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get(); } catch (InterruptedException | ExecutionException e) { @@ -252,20 +245,9 @@ public class ReconciliationServiceImpl implements ReconciliationService, AutoClo return Optional.empty(); } - private void updateReconciliationState(State state) { - ReadWriteTransaction tx = broker.newReadWriteTransaction(); - InstanceIdentifier instanceIdentifier = InstanceIdentifier - .builder(ReconciliationState.class).child(ReconciliationStateList.class, - new ReconciliationStateListKey(nodeId)).build(); - ReconciliationStateListBuilder stateBuilder = new ReconciliationStateListBuilder() - .withKey(new ReconciliationStateListKey(nodeId)) - .setState(state); - try { - tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, stateBuilder.build(), true); - tx.commit().get(); - } catch (InterruptedException | ExecutionException e) { - LOG.error("Exception while updating reconciliation state: {}", nodeId, e); - } + private void updateReconciliationState(final ReconciliationState.ReconciliationStatus status) { + ReconciliationState state = new ReconciliationState(status, LocalDateTime.now()); + reconciliationStates.put(nodeId.toString(),state); } } }