2 * Copyright (c) 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.netvirt.elan.cli.l2gw;
11 import com.google.common.base.Function;
12 import com.google.common.collect.Sets;
13 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
15 import java.io.FileOutputStream;
16 import java.io.PrintWriter;
17 import java.util.ArrayList;
18 import java.util.Collections;
19 import java.util.HashMap;
20 import java.util.List;
22 import java.util.Map.Entry;
23 import java.util.Optional;
25 import java.util.concurrent.ExecutionException;
26 import java.util.stream.Collectors;
27 import org.apache.karaf.shell.commands.Command;
28 import org.apache.karaf.shell.console.OsgiCommandSupport;
29 import org.eclipse.jdt.annotation.Nullable;
30 import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
31 import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
32 import org.opendaylight.mdsal.binding.api.DataBroker;
33 import org.opendaylight.mdsal.binding.api.ReadTransaction;
34 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
35 import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
36 import org.opendaylight.netvirt.elan.l2gw.ha.commands.LogicalSwitchesCmd;
37 import org.opendaylight.netvirt.elan.l2gw.ha.commands.MergeCommand;
38 import org.opendaylight.netvirt.elan.l2gw.ha.commands.RemoteMcastCmd;
39 import org.opendaylight.netvirt.elan.l2gw.ha.commands.RemoteUcastCmd;
40 import org.opendaylight.netvirt.elan.l2gw.ha.commands.TerminationPointCmd;
41 import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
42 import org.opendaylight.netvirt.elan.utils.ElanConstants;
43 import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
44 import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayCache;
45 import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.DevicesKey;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.l2gateways.L2gateway;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsBuilder;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindingsKey;
65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
72 import org.opendaylight.yangtools.yang.binding.DataObject;
73 import org.opendaylight.yangtools.yang.binding.Identifier;
74 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
75 import org.slf4j.Logger;
76 import org.slf4j.LoggerFactory;
78 @Command(scope = "l2gw", name = "validate", description = "Validates the hwvtep nodes data")
79 public class L2GwValidateCli extends OsgiCommandSupport {
81 private static final Logger LOG = LoggerFactory.getLogger(L2GwValidateCli.class);
83 private final MergeCommand[] globalCommands = new MergeCommand[]{new LogicalSwitchesCmd(), new RemoteUcastCmd(),
84 new RemoteMcastCmd()};
85 private final MergeCommand[] physicalSwitchCommands = new MergeCommand[]{new TerminationPointCmd()};
87 private final Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<>();
88 private final Map<InstanceIdentifier<Node>, Node> configNodes = new HashMap<>();
89 private final Map<String, ElanInstance> elanInstanceMap = new HashMap<>();
90 private final Map<Uuid, L2gateway> uuidToL2Gateway = new HashMap<>();
91 private final InstanceIdentifier<Topology> topoIid = HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier();
92 private final Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> operationalNodesData =
94 private final Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> configNodesData =
97 private final DataBroker dataBroker;
98 private final L2GatewayCache l2GatewayCache;
99 private final HwvtepNodeHACache hwvtepNodeHACache;
101 private List<L2gateway> l2gateways;
102 private List<L2gatewayConnection> l2gatewayConnections;
104 private PrintWriter pw;
106 public L2GwValidateCli(DataBroker dataBroker, L2GatewayCache l2GatewayCache,
107 HwvtepNodeHACache hwvtepNodeHACache) {
108 this.dataBroker = dataBroker;
109 this.l2GatewayCache = l2GatewayCache;
110 this.hwvtepNodeHACache = hwvtepNodeHACache;
114 @SuppressFBWarnings("DM_DEFAULT_ENCODING")
116 public Object doExecute() throws Exception {
118 pw = new PrintWriter(new FileOutputStream(new File("l2gw.validation.txt")));
121 verifyConfigVsOperationalDiff();
122 verifyL2GatewayConnections();
124 } catch (ExecutionException | InterruptedException e) {
125 session.getConsole().println("Failed with error " + e.getMessage());
126 LOG.error("Failed with error ", e);
131 private void readNodes() throws ExecutionException, InterruptedException {
132 try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
133 InstanceIdentifier<Topology> topoId = HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier();
135 Optional<Topology> operationalTopoOptional = tx.read(LogicalDatastoreType.OPERATIONAL, topoId).get();
136 Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).get();
138 if (operationalTopoOptional.isPresent()) {
139 for (Node node : operationalTopoOptional.get().nonnullNode().values()) {
140 InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
141 operationalNodes.put(nodeIid, node);
144 if (configTopoOptional.isPresent()) {
145 for (Node node : configTopoOptional.get().nonnullNode().values()) {
146 InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
147 configNodes.put(nodeIid, node);
151 fillNodesData(operationalNodes, operationalNodesData);
152 fillNodesData(configNodes, configNodesData);
154 Optional<ElanInstances> elanInstancesOptional = tx.read(LogicalDatastoreType.CONFIGURATION,
155 InstanceIdentifier.builder(ElanInstances.class).build()).get();
157 if (elanInstancesOptional.isPresent() && elanInstancesOptional.get().getElanInstance() != null) {
158 for (ElanInstance elanInstance : elanInstancesOptional.get().nonnullElanInstance().values()) {
159 elanInstanceMap.put(elanInstance.getElanInstanceName(), elanInstance);
162 l2gatewayConnections = L2GatewayConnectionUtils.getAllL2gatewayConnections(dataBroker);
163 l2gateways = L2GatewayConnectionUtils.getL2gatewayList(dataBroker);
164 for (L2gateway l2gateway : l2gateways) {
165 uuidToL2Gateway.put(l2gateway.getUuid(), l2gateway);
170 private static boolean isPresent(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
171 InstanceIdentifier<Node> nodeIid, InstanceIdentifier dataIid) {
172 if (dataMap.containsKey(nodeIid)) {
173 return dataMap.get(nodeIid).containsKey(dataIid);
179 private static DataObject getData(Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap,
180 InstanceIdentifier<Node> nodeIid, InstanceIdentifier dataIid) {
181 if (dataMap.containsKey(nodeIid)) {
182 return dataMap.get(nodeIid).get(dataIid);
187 private void fillNodesData(Map<InstanceIdentifier<Node>, Node> nodes,
188 Map<InstanceIdentifier<Node>, Map<InstanceIdentifier, DataObject>> dataMap) {
190 for (Map.Entry<InstanceIdentifier<Node>, Node> entry : nodes.entrySet()) {
191 InstanceIdentifier<Node> nodeId = entry.getKey();
192 Node node = entry.getValue();
193 Map<InstanceIdentifier, DataObject> map = new HashMap<>();
194 dataMap.put(nodeId, map);
195 if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
196 for (MergeCommand command : globalCommands) {
197 List<DataObject> data = command.getData(node.augmentation(HwvtepGlobalAugmentation.class));
199 for (DataObject dataObject : data) {
200 map.put(command.generateId(nodeId, dataObject), dataObject);
205 for (MergeCommand command : physicalSwitchCommands) {
206 List<DataObject> data = command.getData(node);
208 for (DataObject dataObject : data) {
209 map.put(command.generateId(nodeId, dataObject), dataObject);
218 * Checks the diff between config and operational topology nodes and prints it to the file if any.
219 * This will tell what is present in the controller config and not in the device
221 private void verifyConfigVsOperationalDiff() {
222 for (Node cfgNode : configNodes.values()) {
223 InstanceIdentifier<Node> nodeId = topoIid.child(Node.class, cfgNode.key());
224 compareNodes(cfgNode, operationalNodes.get(nodeId), false, LogicalDatastoreType.CONFIGURATION);
229 * Checks the diff between HA parent and child nodes.
230 * Whatever config data in parent should be present in child nodes
231 * Whatever operational data in child should be present in parent node
233 private void verifyHANodes() {
234 pw.println("Verifying HA nodes");
235 boolean parentChildComparison = true;
236 Set<InstanceIdentifier<Node>> parentNodes = hwvtepNodeHACache.getHAParentNodes();
237 if (HwvtepHAUtil.isEmpty(parentNodes)) {
240 for (InstanceIdentifier<Node> parentNodeIid : parentNodes) {
241 String parentNodeId = parentNodeIid.firstKeyOf(Node.class).getNodeId().getValue();
242 Node parentOpNode = operationalNodes.get(parentNodeIid);
243 Node parentCfgNode = configNodes.get(parentNodeIid);
244 Set<InstanceIdentifier<Node>> childNodeIids = hwvtepNodeHACache.getChildrenForHANode(parentNodeIid);
245 if (HwvtepHAUtil.isEmpty(childNodeIids)) {
246 pw.println("No child nodes could be found for parent node " + parentNodeId);
249 for (InstanceIdentifier<Node> childNodeIid : childNodeIids) {
250 String childNodeId = childNodeIid.firstKeyOf(Node.class).getNodeId().getValue();
251 if (parentOpNode != null) {
252 compareNodes(parentOpNode, operationalNodes.get(childNodeIid), parentChildComparison,
253 LogicalDatastoreType.OPERATIONAL);
255 pw.println("Missing parent operational node for id " + parentNodeId);
257 if (parentCfgNode != null) {
258 if (configNodes.get(childNodeIid) == null) {
259 if (containsLogicalSwitch(parentCfgNode)) {
260 pw.println("Missing child config data " + childNodeId);
263 compareNodes(parentCfgNode, configNodes.get(childNodeIid), parentChildComparison,
264 LogicalDatastoreType.CONFIGURATION);
267 pw.println("Missing parent config node for id " + parentNodeId);
273 private static boolean containsLogicalSwitch(Node node) {
274 if (node == null || node.augmentation(HwvtepGlobalAugmentation.class) == null
275 || HwvtepHAUtil.isEmptyList(
276 new ArrayList(node.augmentation(HwvtepGlobalAugmentation.class).nonnullLogicalSwitches().values()))) {
282 private boolean compareNodes(Node node1, Node node2, boolean parentChildComparison,
283 LogicalDatastoreType datastoreType) {
285 if (node1 == null || node2 == null) {
288 InstanceIdentifier<Node> nodeIid1 = HwvtepSouthboundUtils.createInstanceIdentifier(node1.getNodeId());
289 InstanceIdentifier<Node> nodeIid2 = HwvtepSouthboundUtils.createInstanceIdentifier(node2.getNodeId());
291 NodeId nodeId1 = nodeIid1.firstKeyOf(Node.class).getNodeId();
292 NodeId nodeId2 = nodeIid2.firstKeyOf(Node.class).getNodeId();
294 PhysicalSwitchAugmentation psAug1 = node1.augmentation(PhysicalSwitchAugmentation.class);
295 PhysicalSwitchAugmentation psAug2 = node2.augmentation(PhysicalSwitchAugmentation.class);
297 HwvtepGlobalAugmentation aug1 = node1.augmentation(HwvtepGlobalAugmentation.class);
298 HwvtepGlobalAugmentation aug2 = node2.augmentation(HwvtepGlobalAugmentation.class);
300 boolean globalNodes = psAug1 == null && psAug2 == null ? true : false;
301 MergeCommand[] commands = globalNodes ? globalCommands : physicalSwitchCommands;
303 for (MergeCommand cmd : commands) {
305 List<DataObject> data1 = null;
306 List<DataObject> data2 = null;
309 data1 = cmd.getData(aug1);
310 data2 = cmd.getData(aug2);
312 data1 = cmd.getData(node1);
313 data2 = cmd.getData(node2);
315 data1 = data1 == null ? Collections.EMPTY_LIST : data1;
316 data2 = data2 == null ? Collections.EMPTY_LIST : data2;
318 if (parentChildComparison) {
319 data2 = cmd.transform(nodeIid1, data2);
321 Function<DataObject, DataObject> withoutUuidTransformer = cmd::withoutUuid;
322 data1 = data1.stream().map(withoutUuidTransformer).collect(Collectors.toList());
323 data2 = data2.stream().map(withoutUuidTransformer).collect(Collectors.toList());
325 Map<Identifier<?>, DataObject> map1 = new HashMap<>();
326 Map<Identifier<?>, DataObject> map2 = new HashMap<>();
327 for (DataObject dataObject : data1) {
328 map1.put(cmd.getKey(dataObject), dataObject);
330 for (DataObject dataObject : data2) {
331 map2.put(cmd.getKey(dataObject), dataObject);
333 Set<DataObject> diff = Sets.newHashSet();
335 for (Entry<Identifier<?>, DataObject> entry : map1.entrySet()) {
336 DataObject obj1 = entry.getValue();
337 DataObject obj2 = map2.get(entry.getKey());
338 if (obj2 == null || !cmd.areEqual(obj1, obj2)) {
343 if (!diff.isEmpty()) {
344 if (parentChildComparison) {
345 pw.println("Missing " + cmd.getDescription() + " child entries in " + datastoreType
346 + " parent node " + nodeId1 + " contain " + " more entries than child "
347 + nodeId2 + " " + diff.size());
349 pw.println("Missing " + cmd.getDescription() + " op entries config "
350 + nodeId1 + " contain " + " more entries than operational node " + diff.size());
352 if (diff.size() < 10) {
353 for (Object obj : diff) {
354 pw.println(cmd.getKey((DataObject) obj));
359 diff = Sets.newHashSet();
360 for (Entry<Identifier<?>, DataObject> entry : map2.entrySet()) {
361 DataObject obj1 = entry.getValue();
362 DataObject obj2 = map1.get(entry.getKey());
363 if (globalNodes || parentChildComparison) {
364 if (obj2 == null || !cmd.areEqual(obj1, obj2)) {
369 if (!diff.isEmpty()) {
370 if (parentChildComparison) {
371 pw.println("Extra " + cmd.getDescription() + " child entries in " + datastoreType + " node "
372 + nodeId2 + " contain " + " more entries than parent node " + nodeId1 + " " + diff.size());
374 pw.println("Extra " + cmd.getDescription() + " operational node "
375 + nodeId2 + " contain " + " more entries than config node " + diff.size());
377 if (diff.size() < 10) {
378 for (Object obj : diff) {
379 pw.println(cmd.getKey((DataObject) obj));
387 private void verifyL2GatewayConnections() {
388 boolean isValid = true;
389 for (L2gatewayConnection l2gatewayConnection : l2gatewayConnections) {
391 L2gateway l2gateway = uuidToL2Gateway.get(l2gatewayConnection.getL2gatewayId());
392 String logicalSwitchName = l2gatewayConnection.getNetworkId().getValue();
393 Map<DevicesKey, Devices> devices = l2gateway.nonnullDevices();
395 for (Devices device : devices.values()) {
397 L2GatewayDevice l2GatewayDevice = l2GatewayCache.get(device.getDeviceName());
398 isValid = verifyL2GatewayDevice(l2gateway, device, l2GatewayDevice);
402 NodeId nodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
403 InstanceIdentifier<Node> nodeIid = topoIid.child(Node.class, new NodeKey(nodeId));
405 isValid = verfiyLogicalSwitch(logicalSwitchName, nodeIid);
407 isValid = verifyMcastMac(logicalSwitchName, nodeIid);
408 verifyVlanBindings(nodeIid, logicalSwitchName, device, l2gatewayConnection.getSegmentId());
409 L2GatewayDevice elanL2gatewayDevice = ElanL2GwCacheUtils
410 .getL2GatewayDeviceFromCache(logicalSwitchName, nodeId.getValue());
411 if (elanL2gatewayDevice == null) {
412 pw.println("Failed elan l2gateway device not found for network " + logicalSwitchName
413 + " and device " + device.getDeviceName() + " " + l2GatewayDevice.getHwvtepNodeId()
414 + " l2gw connection id " + l2gatewayConnection.getUuid());
421 private boolean verifyL2GatewayDevice(L2gateway l2gateway, Devices device, L2GatewayDevice l2GatewayDevice) {
422 if (l2GatewayDevice == null) {
423 pw.println("Failed l2gateway not found in cache for device " + device.getDeviceName());
426 if (l2GatewayDevice.getHwvtepNodeId() == null) {
427 pw.println("L2gateway cache is not updated with node id for device " + device.getDeviceName());
430 if (l2GatewayDevice.getTunnelIp() == null) {
431 pw.println("L2gateway cache is not updated with tunnel ip for device " + device.getDeviceName());
434 if (!l2GatewayDevice.getL2GatewayIds().contains(l2gateway.getUuid())) {
435 pw.println("L2gateway cache is not updated with l2gw id for device " + device.getDeviceName());
441 private static InstanceIdentifier<TerminationPoint> getPhysicalPortTerminationPointIid(NodeId nodeId,
443 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
444 InstanceIdentifier<TerminationPoint> iid = HwvtepSouthboundUtils.createTerminationPointId(nodeId, tpKey);
448 private boolean verfiyLogicalSwitch(String logicalSwitchName, InstanceIdentifier<Node> nodeIid) {
449 NodeId nodeId = nodeIid.firstKeyOf(Node.class).getNodeId();
450 InstanceIdentifier<LogicalSwitches> logicalSwitchPath = HwvtepSouthboundUtils
451 .createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
453 if (!isPresent(configNodesData, nodeIid, logicalSwitchPath)) {
454 pw.println("Failed to find config logical switch " + logicalSwitchName + " for node "
455 + nodeId.getValue());
459 if (!isPresent(operationalNodesData, nodeIid, logicalSwitchPath)) {
460 pw.println("Failed to find operational logical switch " + logicalSwitchName + " for node "
461 + nodeId.getValue());
467 private boolean verifyMcastMac(String logicalSwitchName,
468 InstanceIdentifier<Node> nodeIid) {
469 NodeId nodeId = nodeIid.firstKeyOf(Node.class).getNodeId();
471 HwvtepLogicalSwitchRef lsRef = new HwvtepLogicalSwitchRef(HwvtepSouthboundUtils
472 .createLogicalSwitchesInstanceIdentifier(
473 new NodeId(new Uri(nodeId)), new HwvtepNodeName(logicalSwitchName)));
475 RemoteMcastMacs remoteMcastMac = new RemoteMcastMacsBuilder()
476 .setMacEntryKey(new MacAddress(ElanConstants.UNKNOWN_DMAC)).setLogicalSwitchRef(lsRef).build();
477 InstanceIdentifier<RemoteMcastMacs> mcastMacIid = HwvtepSouthboundUtils
478 .createRemoteMcastMacsInstanceIdentifier(new NodeId(new Uri(nodeId)), remoteMcastMac.key());
481 if (!isPresent(configNodesData, nodeIid, mcastMacIid)) {
482 pw.println("Failed to find config mcast mac for logical switch " + logicalSwitchName
483 + " node id " + nodeId.getValue());
487 if (!isPresent(operationalNodesData, nodeIid, mcastMacIid)) {
488 pw.println("Failed to find operational mcast mac for logical switch " + logicalSwitchName
489 + " node id " + nodeId.getValue());
495 private boolean verifyVlanBindings(InstanceIdentifier<Node> nodeIid,
496 String logicalSwitchName,
497 Devices hwVtepDevice,
498 Integer defaultVlanId) {
499 boolean valid = true;
500 NodeId nodeId = nodeIid.firstKeyOf(Node.class).getNodeId();
501 if (hwVtepDevice.getInterfaces() == null) {
504 for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
505 .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.nonnullInterfaces().values()) {
507 NodeId switchNodeId = HwvtepSouthboundUtils.createManagedNodeId(nodeId, hwVtepDevice.getDeviceName());
508 InstanceIdentifier<Node> physicalSwitchNodeIid = topoIid.child(Node.class, new NodeKey(switchNodeId));
509 InstanceIdentifier<TerminationPoint> terminationPointIid =
510 getPhysicalPortTerminationPointIid(switchNodeId, deviceInterface.getInterfaceName());
512 TerminationPoint operationalTerminationPoint = (TerminationPoint) getData(operationalNodesData,
513 physicalSwitchNodeIid, terminationPointIid);
514 if (operationalTerminationPoint == null) {
516 pw.println("Failed to find the operational port " + deviceInterface.getInterfaceName()
517 + " for node " + hwVtepDevice.getDeviceName() + " nodeid " + nodeId.getValue());
520 TerminationPoint configTerminationPoint = (TerminationPoint) getData(configNodesData,
521 physicalSwitchNodeIid, terminationPointIid);
522 if (configTerminationPoint == null) {
524 pw.println("Failed to find the configurational port " + deviceInterface.getInterfaceName()
525 + " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
526 + " nodeid " + nodeId.getValue());
530 List<VlanBindings> expectedVlans = new ArrayList<>();
531 if (deviceInterface.getSegmentationIds() != null && !deviceInterface.getSegmentationIds().isEmpty()) {
532 for (Integer vlanId : deviceInterface.getSegmentationIds()) {
533 expectedVlans.add(HwvtepSouthboundUtils.createVlanBinding(nodeId, vlanId, logicalSwitchName));
536 expectedVlans.add(HwvtepSouthboundUtils.createVlanBinding(nodeId, defaultVlanId, logicalSwitchName));
539 HwvtepPhysicalPortAugmentation portAugmentation = configTerminationPoint.augmentation(
540 HwvtepPhysicalPortAugmentation.class);
541 if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
542 new ArrayList(portAugmentation.nonnullVlanBindings().values()))) {
543 pw.println("Failed to find the config vlan bindings for port " + deviceInterface.getInterfaceName()
544 + " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
545 + " nodeid " + nodeId.getValue());
549 portAugmentation = operationalTerminationPoint.augmentation(HwvtepPhysicalPortAugmentation.class);
550 if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
551 new ArrayList(portAugmentation.nonnullVlanBindings().values()))) {
552 pw.println("Failed to find the operational vlan bindings for port " + deviceInterface.getInterfaceName()
553 + " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
554 + " nodeid " + nodeId.getValue());
558 VlanBindings expectedBindings = !expectedVlans.isEmpty() ? expectedVlans.get(0) : null;
559 boolean foundBindings = false;
560 Map<VlanBindingsKey, VlanBindings> vlanBindingses = configTerminationPoint.augmentation(
561 HwvtepPhysicalPortAugmentation.class).nonnullVlanBindings();
562 for (VlanBindings actual : vlanBindingses.values()) {
563 if (actual.equals(expectedBindings)) {
564 foundBindings = true;
568 if (!foundBindings) {
569 pw.println("Mismatch in vlan bindings for port " + deviceInterface.getInterfaceName()
570 + " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
571 + " nodeid " + nodeId.getValue());
572 pw.println("Failed to find the vlan bindings " + expectedBindings);
573 pw.println("Actual bindings present in config are ");
574 for (VlanBindings actual : vlanBindingses.values()) {
575 pw.println(actual.toString());