package org.opendaylight.netvirt.elan.cli.l2gw;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.utils.hwvtep.HwvtepHACache;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LogicalSwitchesCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.MergeCommand;
private final DataBroker dataBroker;
private final L2GatewayCache l2GatewayCache;
+ private final HwvtepNodeHACache hwvtepNodeHACache;
private List<L2gateway> l2gateways;
private List<L2gatewayConnection> l2gatewayConnections;
private PrintWriter pw;
- public L2GwValidateCli(DataBroker dataBroker, L2GatewayCache l2GatewayCache) {
+ public L2GwValidateCli(DataBroker dataBroker, L2GatewayCache l2GatewayCache,
+ HwvtepNodeHACache hwvtepNodeHACache) {
this.dataBroker = dataBroker;
this.l2GatewayCache = l2GatewayCache;
+ this.hwvtepNodeHACache = hwvtepNodeHACache;
}
@Override
@SuppressFBWarnings("DM_DEFAULT_ENCODING")
+ @Nullable
public Object doExecute() throws Exception {
try {
pw = new PrintWriter(new FileOutputStream(new File("l2gw.validation.txt")));
verifyConfigVsOperationalDiff();
verifyL2GatewayConnections();
pw.close();
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
session.getConsole().println("Failed with error " + e.getMessage());
LOG.error("Failed with error ", e);
}
return null;
}
- private void readNodes() throws ReadFailedException {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ private void readNodes() throws ExecutionException, InterruptedException {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
InstanceIdentifier<Topology> topoId = HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier();
- Optional<Topology> operationalTopoOptional = tx.read(LogicalDatastoreType.OPERATIONAL, topoId).checkedGet();
- Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).checkedGet();
+ Optional<Topology> operationalTopoOptional = tx.read(LogicalDatastoreType.OPERATIONAL, topoId).get();
+ Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).get();
if (operationalTopoOptional.isPresent()) {
- for (Node node : operationalTopoOptional.get().getNode()) {
- InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.getKey());
+ for (Node node : operationalTopoOptional.get().nonnullNode()) {
+ InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
operationalNodes.put(nodeIid, node);
}
}
if (configTopoOptional.isPresent()) {
- for (Node node : configTopoOptional.get().getNode()) {
- InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.getKey());
+ for (Node node : configTopoOptional.get().nonnullNode()) {
+ InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
configNodes.put(nodeIid, node);
}
}
fillNodesData(configNodes, configNodesData);
Optional<ElanInstances> elanInstancesOptional = tx.read(LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.builder(ElanInstances.class).build()).checkedGet();
+ InstanceIdentifier.builder(ElanInstances.class).build()).get();
if (elanInstancesOptional.isPresent() && elanInstancesOptional.get().getElanInstance() != null) {
for (ElanInstance elanInstance : elanInstancesOptional.get().getElanInstance()) {
}
}
- private boolean isPresent(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
+ private static boolean isPresent(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
InstanceIdentifier<Node> nodeIid, InstanceIdentifier dataIid) {
if (dataMap.containsKey(nodeIid)) {
return dataMap.get(nodeIid).containsKey(dataIid);
return false;
}
- private DataObject getData(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
+ @Nullable
+ private static DataObject getData(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
InstanceIdentifier<Node> nodeIid, InstanceIdentifier dataIid) {
if (dataMap.containsKey(nodeIid)) {
return dataMap.get(nodeIid).get(dataIid);
Node node = entry.getValue();
Map<InstanceIdentifier, DataObject> map = new HashMap<>();
dataMap.put(nodeId, map);
- if (node.getAugmentation(HwvtepGlobalAugmentation.class) != null) {
+ if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
for (MergeCommand command : globalCommands) {
- List<DataObject> data = command.getData(node.getAugmentation(HwvtepGlobalAugmentation.class));
+ List<DataObject> data = command.getData(node.augmentation(HwvtepGlobalAugmentation.class));
if (data != null) {
for (DataObject dataObject : data) {
map.put(command.generateId(nodeId, dataObject), dataObject);
*/
private void verifyConfigVsOperationalDiff() {
for (Node cfgNode : configNodes.values()) {
- InstanceIdentifier<Node> nodeId = topoIid.child(Node.class, cfgNode.getKey());
+ InstanceIdentifier<Node> nodeId = topoIid.child(Node.class, cfgNode.key());
compareNodes(cfgNode, operationalNodes.get(nodeId), false, LogicalDatastoreType.CONFIGURATION);
}
}
private void verifyHANodes() {
pw.println("Verifying HA nodes");
boolean parentChildComparison = true;
- HwvtepHACache haCache = HwvtepHACache.getInstance();
- Set<InstanceIdentifier<Node>> parentNodes = HwvtepHACache.getInstance().getHAParentNodes();
+ Set<InstanceIdentifier<Node>> parentNodes = hwvtepNodeHACache.getHAParentNodes();
if (HwvtepHAUtil.isEmpty(parentNodes)) {
return;
}
String parentNodeId = parentNodeIid.firstKeyOf(Node.class).getNodeId().getValue();
Node parentOpNode = operationalNodes.get(parentNodeIid);
Node parentCfgNode = configNodes.get(parentNodeIid);
- Set<InstanceIdentifier<Node>> childNodeIids = haCache.getChildrenForHANode(parentNodeIid);
+ Set<InstanceIdentifier<Node>> childNodeIids = hwvtepNodeHACache.getChildrenForHANode(parentNodeIid);
if (HwvtepHAUtil.isEmpty(childNodeIids)) {
pw.println("No child nodes could be found for parent node " + parentNodeId);
continue;
}
}
- private boolean containsLogicalSwitch(Node node) {
- if (node == null || node.getAugmentation(HwvtepGlobalAugmentation.class) == null
+ private static boolean containsLogicalSwitch(Node node) {
+ if (node == null || node.augmentation(HwvtepGlobalAugmentation.class) == null
|| HwvtepHAUtil.isEmptyList(
- node.getAugmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches())) {
+ node.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches())) {
return false;
}
return true;
NodeId nodeId1 = nodeIid1.firstKeyOf(Node.class).getNodeId();
NodeId nodeId2 = nodeIid2.firstKeyOf(Node.class).getNodeId();
- PhysicalSwitchAugmentation psAug1 = node1.getAugmentation(PhysicalSwitchAugmentation.class);
- PhysicalSwitchAugmentation psAug2 = node2.getAugmentation(PhysicalSwitchAugmentation.class);
+ PhysicalSwitchAugmentation psAug1 = node1.augmentation(PhysicalSwitchAugmentation.class);
+ PhysicalSwitchAugmentation psAug2 = node2.augmentation(PhysicalSwitchAugmentation.class);
- HwvtepGlobalAugmentation aug1 = node1.getAugmentation(HwvtepGlobalAugmentation.class);
- HwvtepGlobalAugmentation aug2 = node2.getAugmentation(HwvtepGlobalAugmentation.class);
+ HwvtepGlobalAugmentation aug1 = node1.augmentation(HwvtepGlobalAugmentation.class);
+ HwvtepGlobalAugmentation aug2 = node2.augmentation(HwvtepGlobalAugmentation.class);
boolean globalNodes = psAug1 == null && psAug2 == null ? true : false;
MergeCommand[] commands = globalNodes ? globalCommands : physicalSwitchCommands;
data2 = cmd.transform(nodeIid1, data2);
}
Function<DataObject, DataObject> withoutUuidTransformer = cmd::withoutUuid;
- data1 = Lists.transform(data1, withoutUuidTransformer);
- data2 = Lists.transform(data2, withoutUuidTransformer);
+ data1 = data1.stream().map(withoutUuidTransformer).collect(Collectors.toList());
+ data2 = data2.stream().map(withoutUuidTransformer).collect(Collectors.toList());
Map<Identifier<?>, DataObject> map1 = new HashMap<>();
Map<Identifier<?>, DataObject> map2 = new HashMap<>();
L2gateway l2gateway = uuidToL2Gateway.get(l2gatewayConnection.getL2gatewayId());
String logicalSwitchName = l2gatewayConnection.getNetworkId().getValue();
- List<Devices> devices = l2gateway.getDevices();
+ List<Devices> devices = l2gateway.nonnullDevices();
for (Devices device : devices) {
return true;
}
- private InstanceIdentifier<TerminationPoint> getPhysicalPortTerminationPointIid(NodeId nodeId, String portName) {
+ private static InstanceIdentifier<TerminationPoint> getPhysicalPortTerminationPointIid(NodeId nodeId,
+ String portName) {
TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
InstanceIdentifier<TerminationPoint> iid = HwvtepSouthboundUtils.createTerminationPointId(nodeId, tpKey);
return iid;
RemoteMcastMacs remoteMcastMac = new RemoteMcastMacsBuilder()
.setMacEntryKey(new MacAddress(ElanConstants.UNKNOWN_DMAC)).setLogicalSwitchRef(lsRef).build();
InstanceIdentifier<RemoteMcastMacs> mcastMacIid = HwvtepSouthboundUtils
- .createRemoteMcastMacsInstanceIdentifier(new NodeId(new Uri(nodeId)), remoteMcastMac.getKey());
+ .createRemoteMcastMacsInstanceIdentifier(new NodeId(new Uri(nodeId)), remoteMcastMac.key());
if (!isPresent(configNodesData, nodeIid, mcastMacIid)) {
expectedVlans.add(HwvtepSouthboundUtils.createVlanBinding(nodeId, defaultVlanId, logicalSwitchName));
}
- HwvtepPhysicalPortAugmentation portAugmentation = configTerminationPoint.getAugmentation(
+ HwvtepPhysicalPortAugmentation portAugmentation = configTerminationPoint.augmentation(
HwvtepPhysicalPortAugmentation.class);
if (portAugmentation == null || HwvtepHAUtil.isEmptyList(portAugmentation.getVlanBindings())) {
pw.println("Failed to find the config vlan bindings for port " + deviceInterface.getInterfaceName()
valid = false;
continue;
}
- portAugmentation = operationalTerminationPoint.getAugmentation(HwvtepPhysicalPortAugmentation.class);
+ portAugmentation = operationalTerminationPoint.augmentation(HwvtepPhysicalPortAugmentation.class);
if (portAugmentation == null || HwvtepHAUtil.isEmptyList(portAugmentation.getVlanBindings())) {
pw.println("Failed to find the operational vlan bindings for port " + deviceInterface.getInterfaceName()
+ " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
}
VlanBindings expectedBindings = !expectedVlans.isEmpty() ? expectedVlans.get(0) : null;
boolean foundBindings = false;
- List<VlanBindings> vlanBindingses = configTerminationPoint.getAugmentation(
- HwvtepPhysicalPortAugmentation.class).getVlanBindings();
+ List<VlanBindings> vlanBindingses = configTerminationPoint.augmentation(
+ HwvtepPhysicalPortAugmentation.class).nonnullVlanBindings();
for (VlanBindings actual : vlanBindingses) {
if (actual.equals(expectedBindings)) {
foundBindings = true;