-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* 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.frm.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicLong;
-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.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeReconciliation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.StaleGroupKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.AddBundleMessagesInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.AddBundleMessagesInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.AddBundleMessagesOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.ControlBundleInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.ControlBundleInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.ControlBundleOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.SalBundleService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.add.bundle.messages.input.Messages;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.add.bundle.messages.input.MessagesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.add.bundle.messages.input.messages.Message;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.add.bundle.messages.input.messages.MessageBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.BundleAddFlowCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.BundleAddGroupCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.BundleRemoveFlowCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.BundleRemoveGroupCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.bundle.add.flow._case.AddFlowCaseDataBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.bundle.add.group._case.AddGroupCaseDataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.bundle.remove.flow._case.RemoveFlowCaseDataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.bundle.inner.message.grouping.bundle.inner.message.bundle.remove.group._case.RemoveGroupCaseDataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.rev170124.BundleControlType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class FlowNodeReconciliationImpl implements FlowNodeReconciliation {
private static final Logger LOG = LoggerFactory.getLogger(FlowNodeReconciliationImpl.class);
+ private static final Logger OF_EVENT_LOG = LoggerFactory.getLogger("OfEventLog");
// The number of nanoseconds to wait for a single group to be added.
private static final long ADD_GROUP_TIMEOUT = TimeUnit.SECONDS.toNanos(3);
}
}
- private ListenableFuture<Boolean> reconcileConfiguration(InstanceIdentifier<FlowCapableNode> connectedNode) {
+ @Override
+ public ListenableFuture<Boolean> reconcileConfiguration(InstanceIdentifier<FlowCapableNode> connectedNode) {
LOG.info("Triggering reconciliation for device {}", connectedNode.firstKeyOf(Node.class));
if (provider.isStaleMarkingEnabled()) {
LOG.info("Stale-Marking is ENABLED and proceeding with deletion of " + "stale-marked entities on switch {}",
connectedNode.toString());
reconciliationPreProcess(connectedNode);
}
- LOG.debug("Bundle based reconciliation status : {}",
- provider.isBundleBasedReconciliationEnabled() ? "Enable" : "Disable");
if (provider.isBundleBasedReconciliationEnabled()) {
BundleBasedReconciliationTask bundleBasedReconTask = new BundleBasedReconciliationTask(connectedNode);
return JdkFutureAdapters.listenInPoolThread(executor.submit(bundleBasedReconTask));
@Override
public Boolean call() {
- String node = nodeIdentity.firstKeyOf(Node.class, NodeKey.class).getId().getValue();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ String node = nodeIdentity.firstKeyOf(Node.class).getId().getValue();
+ Optional<FlowCapableNode> flowNode = Optional.empty();
BundleId bundleIdValue = new BundleId(BUNDLE_ID.getAndIncrement());
BigInteger dpnId = getDpnIdFromNodeName(node);
- LOG.debug("Triggering bundle based reconciliation for device :{}", dpnId);
- ReadOnlyTransaction trans = provider.getReadTranaction();
- try {
+ LOG.info("Triggering bundle based reconciliation for device : {}", dpnId);
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
} catch (ExecutionException | InterruptedException e) {
LOG.error("Error occurred while reading the configuration data store for node {}", nodeIdentity, e);
if (flowNode.isPresent()) {
LOG.debug("FlowNode present for Datapath ID {}", dpnId);
+ OF_EVENT_LOG.debug("Bundle Reconciliation Start, Node: {}", dpnId);
final NodeRef nodeRef = new NodeRef(nodeIdentity.firstIdentifierOf(Node.class));
+ final ControlBundleInput closeBundleInput = new ControlBundleInputBuilder().setNode(nodeRef)
+ .setBundleId(bundleIdValue).setFlags(BUNDLE_FLAGS)
+ .setType(BundleControlType.ONFBCTCLOSEREQUEST).build();
+
final ControlBundleInput openBundleInput = new ControlBundleInputBuilder().setNode(nodeRef)
.setBundleId(bundleIdValue).setFlags(BUNDLE_FLAGS).setType(BundleControlType.ONFBCTOPENREQUEST)
.build();
.setBundleId(bundleIdValue).setFlags(BUNDLE_FLAGS)
.setType(BundleControlType.ONFBCTCOMMITREQUEST).build();
- final AddBundleMessagesInput addBundleMessagesInput = new AddBundleMessagesInputBuilder()
+ final AddBundleMessagesInput deleteAllFlowGroupsInput = new AddBundleMessagesInputBuilder()
.setNode(nodeRef).setBundleId(bundleIdValue).setFlags(BUNDLE_FLAGS)
- .setMessages(createMessages(nodeRef, flowNode)).build();
-
- Future<RpcResult<Void>> openBundle = salBundleService.controlBundle(openBundleInput);
+ .setMessages(createMessages(nodeRef)).build();
+
+ LOG.debug("Closing openflow bundle for device {}", dpnId);
+ /* Close previously opened bundle on the openflow switch if any */
+ ListenableFuture<RpcResult<ControlBundleOutput>> closeBundle
+ = salBundleService.controlBundle(closeBundleInput);
+
+ /* Open a new bundle on the switch */
+ ListenableFuture<RpcResult<ControlBundleOutput>> openBundle =
+ Futures.transformAsync(closeBundle,
+ rpcResult -> salBundleService.controlBundle(openBundleInput),
+ MoreExecutors.directExecutor());
+
+ /* Push groups and flows via bundle add messages */
+ ListenableFuture<RpcResult<AddBundleMessagesOutput>> deleteAllFlowGroupsFuture
+ = Futures.transformAsync(openBundle, rpcResult -> {
+ if (rpcResult.isSuccessful()) {
+ return salBundleService.addBundleMessages(deleteAllFlowGroupsInput);
+ }
+ return Futures.immediateFuture(null);
+ }, MoreExecutors.directExecutor());
- ListenableFuture<RpcResult<Void>> addBundleMessagesFuture = Futures
- .transformAsync(JdkFutureAdapters.listenInPoolThread(openBundle), rpcResult -> {
+ /* Push flows and groups via bundle add messages */
+ Optional<FlowCapableNode> finalFlowNode = flowNode;
+ ListenableFuture<List<RpcResult<AddBundleMessagesOutput>>> addbundlesFuture
+ = Futures.transformAsync(deleteAllFlowGroupsFuture, rpcResult -> {
if (rpcResult.isSuccessful()) {
- return JdkFutureAdapters
- .listenInPoolThread(salBundleService.addBundleMessages(addBundleMessagesInput));
+ LOG.debug("Adding delete all flow/group message is successful for device {}", dpnId);
+ return Futures.allAsList(addBundleMessages(finalFlowNode.get(), bundleIdValue,
+ nodeIdentity));
}
return Futures.immediateFuture(null);
- });
- ListenableFuture<RpcResult<Void>> commitBundleFuture = Futures.transformAsync(addBundleMessagesFuture,
- rpcResult -> {
- if (rpcResult.isSuccessful()) {
- return JdkFutureAdapters
- .listenInPoolThread(salBundleService.controlBundle(commitBundleInput));
- }
- return Futures.immediateFuture(null);
- });
+ }, MoreExecutors.directExecutor());
+
+ /* Commit the bundle on the openflow switch */
+ ListenableFuture<RpcResult<ControlBundleOutput>> commitBundleFuture = Futures.transformAsync(
+ addbundlesFuture, rpcResult -> {
+ LOG.debug("Adding bundle messages completed for device {}", dpnId);
+ return salBundleService.controlBundle(commitBundleInput);
+ }, MoreExecutors.directExecutor());
/* Bundles not supported for meters */
List<Meter> meters = flowNode.get().getMeter() != null ? flowNode.get().getMeter()
if (rpcResult.isSuccessful()) {
for (Meter meter : meters) {
final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdentity
- .child(Meter.class, meter.getKey());
+ .child(Meter.class, meter.key());
provider.getMeterCommiter().add(meterIdent, meter, nodeIdentity);
}
}
return Futures.immediateFuture(null);
- });
-
- trans.close();
+ }, MoreExecutors.directExecutor());
try {
- if (commitBundleFuture.get().isSuccessful()) {
+ RpcResult<ControlBundleOutput> bundleFuture = commitBundleFuture.get();
+ if (bundleFuture != null && bundleFuture.isSuccessful()) {
LOG.debug("Completing bundle based reconciliation for device ID:{}", dpnId);
+ OF_EVENT_LOG.debug("Bundle Reconciliation Finish, Node: {}", dpnId);
return true;
} else {
+ LOG.error("commit bundle failed for device {} with error {}", dpnId,
+ commitBundleFuture.get().getErrors());
return false;
}
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Error while doing bundle based reconciliation for device ID:{}", nodeIdentity);
+ LOG.error("Error while doing bundle based reconciliation for device ID:{}", dpnId);
return false;
}
}
public ListenableFuture<Boolean> startReconciliation(DeviceInfo node) {
InstanceIdentifier<FlowCapableNode> connectedNode = node.getNodeInstanceIdentifier()
.augmentation(FlowCapableNode.class);
+ // Clearing the group registry cache for the connected node if exists
+ provider.getDevicesGroupRegistry().clearNodeGroups(node.getNodeId());
return futureMap.computeIfAbsent(node, future -> reconcileConfiguration(connectedNode));
}
@Override
public Boolean call() {
- String node = nodeIdentity.firstKeyOf(Node.class, NodeKey.class).getId().getValue();
+ String node = nodeIdentity.firstKeyOf(Node.class).getId().getValue();
BigInteger dpnId = getDpnIdFromNodeName(node);
+ OF_EVENT_LOG.debug("Reconciliation Start, Node: {}", dpnId);
- ReadOnlyTransaction trans = provider.getReadTranaction();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ Optional<FlowCapableNode> flowNode;
// initialize the counter
int counter = 0;
- try {
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Fail with read Config/DS for Node {} !", nodeIdentity, e);
? flowNode.get().getTableFeatures()
: Collections.<TableFeatures>emptyList();
for (TableFeatures tableFeaturesItem : tableList) {
- TableFeaturesKey tableKey = tableFeaturesItem.getKey();
+ TableFeaturesKey tableKey = tableFeaturesItem.key();
KeyedInstanceIdentifier<TableFeatures, TableFeaturesKey> tableFeaturesII = nodeIdentity
.child(TableFeatures.class, new TableFeaturesKey(tableKey.getTableId()));
provider.getTableFeaturesCommiter().update(tableFeaturesII, tableFeaturesItem, null, nodeIdentity);
// new list for suspected groups pointing to ports .. when the ports come up
// late
List<Group> suspectedGroups = new ArrayList<>();
- Map<Long, ListenableFuture<?>> groupFutures = new HashMap<>();
+ Map<Uint32, ListenableFuture<?>> groupFutures = new HashMap<>();
while ((!toBeInstalledGroups.isEmpty() || !suspectedGroups.isEmpty())
&& counter <= provider.getReconciliationRetryCount()) { // also check if the counter has not
}
for (Action action : actions) {
// chained-port
- if (action.getAction().getImplementedInterface().getName()
+ if (action.getAction().implementedInterface().getName()
.equals("org.opendaylight.yang.gen.v1.urn.opendaylight"
+ ".action.types.rev131112.action.action.OutputActionCase")) {
String nodeConnectorUri = ((OutputActionCase) action.getAction()).getOutputAction()
nodeConnectorUri, group.getGroupId().toString());
break;
}
- } else if (action.getAction().getImplementedInterface().getName()
+ } else if (action.getAction().implementedInterface().getName()
.equals("org.opendaylight.yang.gen.v1.urn.opendaylight"
+ ".action.types.rev131112.action.action.GroupActionCase")) {
// chained groups
- Long groupId = ((GroupActionCase) action.getAction()).getGroupAction().getGroupId();
+ Uint32 groupId = ((GroupActionCase) action.getAction()).getGroupAction()
+ .getGroupId();
ListenableFuture<?> future = groupFutures.get(groupId);
if (future == null) {
okToInstall = false;
: Collections.<Meter>emptyList();
for (Meter meter : meters) {
final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdentity.child(Meter.class,
- meter.getKey());
+ meter.key());
provider.getMeterCommiter().add(meterIdent, meter, nodeIdentity);
}
/* Flows */
List<Table> tables = flowNode.get().getTable() != null ? flowNode.get().getTable()
: Collections.<Table>emptyList();
+ int flowCount = 0;
for (Table table : tables) {
final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdentity.child(Table.class,
- table.getKey());
+ table.key());
List<Flow> flows = table.getFlow() != null ? table.getFlow() : Collections.<Flow>emptyList();
+ flowCount += flows.size();
for (Flow flow : flows) {
final KeyedInstanceIdentifier<Flow, FlowKey> flowIdent = tableIdent.child(Flow.class,
- flow.getKey());
+ flow.key());
provider.getFlowCommiter().add(flowIdent, flow, nodeIdentity);
}
}
+ OF_EVENT_LOG.debug("Reconciliation Finish, Node: {}, flow count: {}", dpnId, flowCount);
}
- /* clean transaction */
- trans.close();
return true;
}
* @param group
* The group to add.
*/
- private void addGroup(Map<Long, ListenableFuture<?>> map, Group group) {
- KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdentity.child(Group.class, group.getKey());
- final Long groupId = group.getGroupId().getValue();
+ private void addGroup(Map<Uint32, ListenableFuture<?>> map, Group group) {
+ KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdentity.child(Group.class, group.key());
+ final Uint32 groupId = group.getGroupId().getValue();
ListenableFuture<?> future = JdkFutureAdapters
.listenInPoolThread(provider.getGroupCommiter().add(groupIdent, group, nodeIdentity));
@Override
public void onFailure(Throwable cause) {
- String msg = "add-group RPC failed: node=" + nodeIdentity.firstKeyOf(Node.class).getId().getValue()
- + ", id=" + groupId;
- LOG.debug(msg, cause);
+ LOG.debug("add-group RPC failed: node={}, id={}",
+ nodeIdentity.firstKeyOf(Node.class).getId().getValue(), groupId, cause);
}
}, MoreExecutors.directExecutor());
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private BigInteger getDpnIdFromNodeName(String nodeName) {
String dpId = nodeName.substring(nodeName.lastIndexOf(SEPARATOR) + 1);
List<InstanceIdentifier<StaleGroup>> staleGroupsToBeBulkDeleted = Lists.newArrayList();
List<InstanceIdentifier<StaleMeter>> staleMetersToBeBulkDeleted = Lists.newArrayList();
- ReadOnlyTransaction trans = provider.getReadTranaction();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ Optional<FlowCapableNode> flowNode = Optional.empty();
- try {
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdent).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Reconciliation Pre-Processing Fail with read Config/DS for Node {} !", nodeIdent, e);
: Collections.<Table>emptyList();
for (Table table : tables) {
final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdent.child(Table.class,
- table.getKey());
+ table.key());
List<StaleFlow> staleFlows = table.getStaleFlow() != null ? table.getStaleFlow()
: Collections.<StaleFlow>emptyList();
for (StaleFlow staleFlow : staleFlows) {
Flow toBeDeletedFlow = flowBuilder.setId(staleFlow.getId()).build();
final KeyedInstanceIdentifier<Flow, FlowKey> flowIdent = tableIdent.child(Flow.class,
- toBeDeletedFlow.getKey());
+ toBeDeletedFlow.key());
this.provider.getFlowCommiter().remove(flowIdent, toBeDeletedFlow, nodeIdent);
Group toBeDeletedGroup = groupBuilder.setGroupId(staleGroup.getGroupId()).build();
final KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdent.child(Group.class,
- toBeDeletedGroup.getKey());
+ toBeDeletedGroup.key());
this.provider.getGroupCommiter().remove(groupIdent, toBeDeletedGroup, nodeIdent);
Meter toBeDeletedMeter = meterBuilder.setMeterId(staleMeter.getMeterId()).build();
final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdent.child(Meter.class,
- toBeDeletedMeter.getKey());
+ toBeDeletedMeter.key());
this.provider.getMeterCommiter().remove(meterIdent, toBeDeletedMeter, nodeIdent);
}
}
- /* clean transaction */
- trans.close();
LOG.debug("Deleting all stale-marked flows/groups/meters of for switch {} in Configuration DS",
nodeIdent.toString());
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleFlowIId);
}
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleGroupIId);
}
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleMeterIId);
}
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
return nodeIdent.child(StaleMeter.class, new StaleMeterKey(new MeterId(staleMeter.getMeterId())));
}
- private void handleStaleEntityDeletionResultFuture(
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture) {
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private List<ListenableFuture<RpcResult<AddBundleMessagesOutput>>> addBundleMessages(final FlowCapableNode flowNode,
+ final BundleId bundleIdValue,
+ final InstanceIdentifier<FlowCapableNode> nodeIdentity) {
+ List<ListenableFuture<RpcResult<AddBundleMessagesOutput>>> futureList = new ArrayList<>();
+ for (Group group : flowNode.nonnullGroup()) {
+ final KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdentity.child(Group.class, group.key());
+ futureList.add(provider.getBundleGroupListener().add(groupIdent, group, nodeIdentity, bundleIdValue));
+ }
+
+ for (Table table : flowNode.nonnullTable()) {
+ final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdentity.child(Table.class, table.key());
+ for (Flow flow : table.nonnullFlow()) {
+ final KeyedInstanceIdentifier<Flow, FlowKey> flowIdent = tableIdent.child(Flow.class, flow.key());
+ futureList.add(provider.getBundleFlowListener().add(flowIdent, flow, nodeIdentity, bundleIdValue));
+ }
+ }
+ OF_EVENT_LOG.debug("Flow/Group count is {}", futureList.size());
+ return futureList;
+ }
+
+ private void handleStaleEntityDeletionResultFuture(FluentFuture<?> submitFuture) {
+ submitFuture.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Object result) {
LOG.debug("Stale entity removal success");
}
@Override
public void onFailure(Throwable throwable) {
- LOG.debug("Stale entity removal failed {}", throwable);
+ LOG.debug("Stale entity removal failed", throwable);
}
}, MoreExecutors.directExecutor());
}
return groupBuilder.build();
}
- private Messages createMessages(final NodeRef nodeRef, final Optional<FlowCapableNode> flowNode) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private Messages createMessages(final NodeRef nodeRef) {
final List<Message> messages = new ArrayList<>();
messages.add(new MessageBuilder().setNode(nodeRef)
.setBundleInnerMessage(new BundleRemoveFlowCaseBuilder()
.setBundleInnerMessage(new BundleRemoveGroupCaseBuilder()
.setRemoveGroupCaseData(new RemoveGroupCaseDataBuilder(getDeleteAllGroup()).build()).build())
.build());
-
- if (flowNode.get().getGroup() != null) {
- for (Group gr : flowNode.get().getGroup()) {
- messages.add(new MessageBuilder().setNode(nodeRef).setBundleInnerMessage(new BundleAddGroupCaseBuilder()
- .setAddGroupCaseData(new AddGroupCaseDataBuilder(gr).build()).build()).build());
- }
- }
-
- if (flowNode.get().getTable() != null) {
- for (Table table : flowNode.get().getTable()) {
- for (Flow flow : table.getFlow()) {
- messages.add(
- new MessageBuilder().setNode(nodeRef)
- .setBundleInnerMessage(new BundleAddFlowCaseBuilder()
- .setAddFlowCaseData(new AddFlowCaseDataBuilder(flow).build()).build())
- .build());
- }
- }
- }
-
- LOG.debug("The size of the flows and group messages created in createMessage() {}", messages.size());
return new MessagesBuilder().setMessage(messages).build();
}
}
Code Review / openflowplugin.git / blobdiff