3 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
5 * This program and the accompanying materials are made available under the
6 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
7 * and is available at http://www.eclipse.org/legal/epl-v10.html
10 package org.opendaylight.controller.protocol_plugin.openflow.internal;
12 import java.util.ArrayList;
13 import java.util.Collection;
14 import java.util.HashSet;
15 import java.util.List;
18 import java.util.Timer;
19 import java.util.TimerTask;
20 import java.util.concurrent.BlockingQueue;
21 import java.util.concurrent.ConcurrentHashMap;
22 import java.util.concurrent.ConcurrentMap;
23 import java.util.concurrent.CopyOnWriteArrayList;
24 import java.util.concurrent.LinkedBlockingQueue;
26 import org.eclipse.osgi.framework.console.CommandInterpreter;
27 import org.eclipse.osgi.framework.console.CommandProvider;
28 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketListen;
29 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketMux;
30 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimExternalListener;
31 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
32 import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
33 import org.openflow.protocol.OFPhysicalPort;
34 import org.osgi.framework.BundleContext;
35 import org.osgi.framework.FrameworkUtil;
36 import org.slf4j.Logger;
37 import org.slf4j.LoggerFactory;
39 import org.opendaylight.controller.sal.core.Config;
40 import org.opendaylight.controller.sal.core.ConstructionException;
41 import org.opendaylight.controller.sal.core.Edge;
42 import org.opendaylight.controller.sal.core.ContainerFlow;
43 import org.opendaylight.controller.sal.core.IContainerListener;
44 import org.opendaylight.controller.sal.core.Node;
45 import org.opendaylight.controller.sal.core.NodeConnector;
46 import org.opendaylight.controller.sal.core.Property;
47 import org.opendaylight.controller.sal.core.State;
48 import org.opendaylight.controller.sal.core.UpdateType;
49 import org.opendaylight.controller.sal.discovery.IDiscoveryService;
50 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
51 import org.opendaylight.controller.sal.packet.Ethernet;
52 import org.opendaylight.controller.sal.packet.LLDP;
53 import org.opendaylight.controller.sal.packet.LLDPTLV;
54 import org.opendaylight.controller.sal.packet.LinkEncap;
55 import org.opendaylight.controller.sal.packet.PacketResult;
56 import org.opendaylight.controller.sal.packet.RawPacket;
57 import org.opendaylight.controller.sal.utils.EtherTypes;
58 import org.opendaylight.controller.sal.utils.HexEncode;
59 import org.opendaylight.controller.sal.utils.NetUtils;
60 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
61 import org.opendaylight.controller.sal.utils.NodeCreator;
64 * The class describes neighbor discovery service for an OpenFlow network.
66 public class DiscoveryService implements IInventoryShimExternalListener,
67 IDataPacketListen, IContainerListener, CommandProvider {
68 private static Logger logger = LoggerFactory
69 .getLogger(DiscoveryService.class);
70 private IController controller = null;
71 private IDiscoveryService discoveryService = null;
72 private IPluginInInventoryService pluginInInventoryService = null;
73 private IDataPacketMux iDataPacketMux = null;
75 private List<NodeConnector> readyListHi = null; // newly added ports go into this list and will be served first
76 private List<NodeConnector> readyListLo = null; // come here after served at least once
77 private List<NodeConnector> waitingList = null; // staging area during quiet period
78 private ConcurrentMap<NodeConnector, Integer> pendingMap = null;// wait for response back
79 private ConcurrentMap<NodeConnector, Edge> edgeMap = null; // openflow edges keyed by head connector
80 private ConcurrentMap<NodeConnector, Integer> agingMap = null; // aging entries keyed by edge port
81 private ConcurrentMap<NodeConnector, Edge> prodMap = null; // production edges keyed by edge port
83 private Timer discoveryTimer; // discovery timer
84 private DiscoveryTimerTask discoveryTimerTask; // timer task
85 private long discoveryTimerTick = 1L * 1000; // per tick in msec
86 private int discoveryTimerTickCount = 0; // main tick counter
87 private int discoveryBatchMaxPorts = 500; // max # of ports handled in one batch
88 private int discoveryBatchPauseTicks = 28; // pause a little bit after this point
89 private int discoveryBatchRestartTicks = 30; // periodically restart batching process
90 private int discoveryRetry = 1; // number of retry after initial timeout
91 private int discoveryTimeoutTicks = 2; // timeout 2 sec
92 private int discoveryAgeoutTicks = 120; // age out 2 min
93 private int discoveryConsistencyCheckMultiple = 2; // multiple of discoveryBatchRestartTicks
94 private int discoveryConsistencyCheckTickCount = discoveryBatchPauseTicks; // CC tick counter
95 private int discoveryConsistencyCheckCallingTimes = 0; // # of times CC gets called
96 private int discoveryConsistencyCheckCorrected = 0; // # of cases CC corrected
97 private boolean discoveryConsistencyCheckEnabled = true;// enable or disable CC
98 private boolean discoveryAgingEnabled = true; // enable or disable aging
99 private boolean discoverySpoofingEnabled = true; // enable or disable spoofing neighbor of a production network
101 private BlockingQueue<NodeConnector> transmitQ;
102 private Thread transmitThread;
103 private Boolean throttling = false; // if true, no more batching.
104 private volatile Boolean shuttingDown = false;
106 private LLDPTLV chassisIdTlv, portIdTlv, ttlTlv, customTlv;
108 class DiscoveryTransmit implements Runnable {
109 private final BlockingQueue<NodeConnector> transmitQ;
111 DiscoveryTransmit(BlockingQueue<NodeConnector> transmitQ) {
112 this.transmitQ = transmitQ;
118 NodeConnector nodeConnector = transmitQ.take();
119 RawPacket outPkt = createDiscoveryPacket(nodeConnector);
120 sendDiscoveryPacket(nodeConnector, outPkt);
121 nodeConnector = null;
122 } catch (InterruptedException e1) {
124 .warn("DiscoveryTransmit interupted", e1
128 } catch (Exception e2) {
129 e2.printStackTrace();
135 class DiscoveryTimerTask extends TimerTask {
139 doConsistencyCheck();
144 private RawPacket createDiscoveryPacket(NodeConnector nodeConnector) {
145 String nodeId = HexEncode.longToHexString((Long) nodeConnector
148 // Create LLDP ChassisID TLV
149 byte[] cidValue = LLDPTLV.createChassisIDTLVValue(nodeId);
150 chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue())
151 .setLength((short) cidValue.length).setValue(cidValue);
153 // Create LLDP PortID TLV
154 String portId = nodeConnector.getNodeConnectorIDString();
155 byte[] pidValue = LLDPTLV.createPortIDTLVValue(portId);
156 portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue())
157 .setLength((short) pidValue.length).setValue(pidValue);
159 // Create LLDP Custom TLV
160 byte[] customValue = LLDPTLV.createCustomTLVValue(nodeConnector.toString());
161 customTlv.setType((byte) LLDPTLV.TLVType.Custom.getValue())
162 .setLength((short) customValue.length).setValue(customValue);
164 // Create LLDP Custom Option list
165 List<LLDPTLV> customList = new ArrayList<LLDPTLV>();
166 customList.add(customTlv);
168 // Create discovery pkt
169 LLDP discoveryPkt = new LLDP();
170 discoveryPkt.setChassisId(chassisIdTlv).setPortId(portIdTlv).setTtl(
171 ttlTlv).setOptionalTLVList(customList);
173 RawPacket rawPkt = null;
175 // Create ethernet pkt
176 byte[] sourceMac = getSouceMACFromNodeID(nodeId);
177 Ethernet ethPkt = new Ethernet();
178 ethPkt.setSourceMACAddress(sourceMac).setDestinationMACAddress(
179 LLDP.LLDPMulticastMac).setEtherType(
180 EtherTypes.LLDP.shortValue()).setPayload(discoveryPkt);
182 byte[] data = ethPkt.serialize();
183 rawPkt = new RawPacket(data);
184 rawPkt.setOutgoingNodeConnector(nodeConnector);
185 } catch (ConstructionException cex) {
186 logger.debug("RawPacket creation caught exception {}", cex
188 } catch (Exception e) {
189 logger.error("Failed to serialize the LLDP packet: " + e);
195 private void sendDiscoveryPacket(NodeConnector nodeConnector,
197 if (nodeConnector == null) {
198 logger.error("nodeConnector is null");
202 if (outPkt == null) {
203 logger.error("outPkt is null");
207 long sid = (Long) nodeConnector.getNode().getID();
208 ISwitch sw = controller.getSwitches().get(sid);
211 logger.error("Switch of swid {} is null", sid);
215 if (!sw.isOperational()) {
216 logger.error("Switch {} is not operational", sw);
220 if (this.iDataPacketMux == null) {
221 logger.error("Cannot send discover packets out");
225 logger.trace("Sending topology discovery pkt thru {}", nodeConnector);
226 this.iDataPacketMux.transmitDataPacket(outPkt);
230 public PacketResult receiveDataPacket(RawPacket inPkt) {
232 logger.debug("Ignoring null packet");
233 return PacketResult.IGNORED;
236 byte[] data = inPkt.getPacketData();
237 if (data.length <= 0) {
238 logger.trace("Ignoring zero length packet");
239 return PacketResult.IGNORED;
242 if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) {
243 logger.trace("Ignoring non ethernet packet");
244 return PacketResult.IGNORED;
247 if (((Short) inPkt.getIncomingNodeConnector().getID())
248 .equals(NodeConnector.SPECIALNODECONNECTORID)) {
249 logger.trace("Ignoring ethernet packet received on special port: "
250 + inPkt.getIncomingNodeConnector().toString());
251 return PacketResult.IGNORED;
254 Ethernet ethPkt = new Ethernet();
256 ethPkt.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
257 } catch (Exception e) {
258 logger.warn("Failed to decode LLDP packet from "
259 + inPkt.getIncomingNodeConnector() + ": " + e);
260 return PacketResult.IGNORED;
262 if (ethPkt.getPayload() instanceof LLDP) {
263 NodeConnector dst = inPkt.getIncomingNodeConnector();
264 if (!processDiscoveryPacket(dst, ethPkt)) {
265 /* Spoof the discovery pkt if not generated from us */
266 spoofDiscoveryPacket(dst, ethPkt);
268 return PacketResult.CONSUME;
270 return PacketResult.IGNORED;
274 * Spoof incoming discovery frames generated by the production network neighbor switch
276 private void spoofDiscoveryPacket(NodeConnector dstNodeConnector,
278 if (!this.discoverySpoofingEnabled) {
282 if ((dstNodeConnector == null) || (ethPkt == null)) {
284 .trace("Ignoring processing of discovery packet: Null node connector or packet");
288 logger.trace("Handle discovery packet {} from {}", ethPkt,
291 LLDP lldp = (LLDP) ethPkt.getPayload();
294 String nodeId = LLDPTLV.getHexStringValue(lldp.getChassisId().getValue(), lldp.getChassisId().getLength());
295 String portId = LLDPTLV.getStringValue(lldp.getPortId().getValue(), lldp.getPortId().getLength());
296 Node srcNode = new Node(Node.NodeIDType.PRODUCTION, nodeId);
297 NodeConnector srcNodeConnector = NodeConnectorCreator
298 .createNodeConnector(
299 NodeConnector.NodeConnectorIDType.PRODUCTION,
302 // push it out to Topology
304 Set<Property> props = null;
306 edge = new Edge(srcNodeConnector, dstNodeConnector);
307 props = getProps(dstNodeConnector);
308 } catch (ConstructionException e) {
309 logger.error(e.getMessage());
311 addEdge(edge, props);
313 logger.trace("Received discovery packet for Edge {}", edge);
314 } catch (Exception e) {
320 * Handle discovery frames generated by our controller
321 * @return true if it's a success
323 private boolean processDiscoveryPacket(NodeConnector dstNodeConnector,
325 if ((dstNodeConnector == null) || (ethPkt == null)) {
327 .trace("Ignoring processing of discovery packet: Null node connector or packet");
331 logger.trace("Handle discovery packet {} from {}", ethPkt,
334 LLDP lldp = (LLDP) ethPkt.getPayload();
336 List<LLDPTLV> optionalTLVList = lldp.getOptionalTLVList();
337 if (optionalTLVList == null) {
338 logger.info("The discovery packet with null custom option from {}",
344 NodeConnector srcNodeConnector = null;
345 for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) {
346 if (lldptlv.getType() == LLDPTLV.TLVType.Custom.getValue()) {
347 String ncString = LLDPTLV.getCustomString(lldptlv.getValue(), lldptlv.getLength());
348 srcNodeConnector = NodeConnector.fromString(ncString);
349 if (srcNodeConnector != null) {
350 srcNode = srcNodeConnector.getNode();
351 /* Check if it's expected */
352 if (isTracked(srcNodeConnector)) {
356 srcNodeConnector = null;
362 if ((srcNode == null) || (srcNodeConnector == null)) {
365 "Received non-controller generated discovery packet from {}",
370 // push it out to Topology
372 Set<Property> props = null;
374 edge = new Edge(srcNodeConnector, dstNodeConnector);
375 props = getProps(dstNodeConnector);
376 } catch (ConstructionException e) {
377 logger.error(e.getMessage());
379 addEdge(edge, props);
381 logger.trace("Received discovery packet for Edge {}", edge);
386 public Map<String, Property> getPropMap(NodeConnector nodeConnector) {
387 if (nodeConnector == null) {
391 if (pluginInInventoryService == null) {
395 Map<NodeConnector, Map<String, Property>> props = pluginInInventoryService
396 .getNodeConnectorProps(false);
401 return props.get(nodeConnector);
404 public Property getProp(NodeConnector nodeConnector, String propName) {
405 Map<String, Property> propMap = getPropMap(nodeConnector);
406 if (propMap == null) {
410 Property prop = (Property) propMap.get(propName);
414 public Set<Property> getProps(NodeConnector nodeConnector) {
415 Map<String, Property> propMap = getPropMap(nodeConnector);
416 if (propMap == null) {
420 Set<Property> props = new HashSet<Property>(propMap.values());
424 private boolean isEnabled(NodeConnector nodeConnector) {
425 if (nodeConnector == null) {
429 Config config = (Config) getProp(nodeConnector, Config.ConfigPropName);
430 State state = (State) getProp(nodeConnector, State.StatePropName);
431 return ((config != null) && (config.getValue() == Config.ADMIN_UP)
432 && (state != null) && (state.getValue() == State.EDGE_UP));
435 private boolean isTracked(NodeConnector nodeConnector) {
436 if (readyListHi.contains(nodeConnector)) {
440 if (readyListLo.contains(nodeConnector)) {
444 if (pendingMap.keySet().contains(nodeConnector)) {
448 if (waitingList.contains(nodeConnector)) {
455 private Set<NodeConnector> getWorkingSet() {
456 Set<NodeConnector> workingSet = new HashSet<NodeConnector>();
457 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
459 for (NodeConnector nodeConnector : readyListHi) {
460 if (isOverLimit(workingSet.size())) {
464 workingSet.add(nodeConnector);
465 removeSet.add(nodeConnector);
467 readyListHi.removeAll(removeSet);
470 for (NodeConnector nodeConnector : readyListLo) {
471 if (isOverLimit(workingSet.size())) {
475 workingSet.add(nodeConnector);
476 removeSet.add(nodeConnector);
478 readyListLo.removeAll(removeSet);
483 private Boolean isOverLimit(int size) {
484 return ((size >= discoveryBatchMaxPorts) && !throttling);
487 private void addDiscovery() {
488 Map<Long, ISwitch> switches = controller.getSwitches();
489 Set<Long> sidSet = switches.keySet();
490 if (sidSet == null) {
493 for (Long sid : sidSet) {
494 Node node = NodeCreator.createOFNode(sid);
499 private void addDiscovery(Node node) {
500 Map<Long, ISwitch> switches = controller.getSwitches();
501 ISwitch sw = switches.get((Long) node.getID());
502 List<OFPhysicalPort> ports = sw.getEnabledPorts();
506 for (OFPhysicalPort port : ports) {
507 NodeConnector nodeConnector = NodeConnectorCreator
508 .createOFNodeConnector(port.getPortNumber(), node);
509 if (!readyListHi.contains(nodeConnector)) {
510 readyListHi.add(nodeConnector);
515 private void addDiscovery(NodeConnector nodeConnector) {
516 if (isTracked(nodeConnector)) {
520 readyListHi.add(nodeConnector);
523 private Set<NodeConnector> getRemoveSet(Collection<NodeConnector> c,
525 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
529 for (NodeConnector nodeConnector : c) {
530 if (node.equals(nodeConnector.getNode())) {
531 removeSet.add(nodeConnector);
537 private void removeDiscovery(Node node) {
538 Set<NodeConnector> removeSet;
540 removeSet = getRemoveSet(readyListHi, node);
541 readyListHi.removeAll(removeSet);
543 removeSet = getRemoveSet(readyListLo, node);
544 readyListLo.removeAll(removeSet);
546 removeSet = getRemoveSet(waitingList, node);
547 waitingList.removeAll(removeSet);
549 removeSet = getRemoveSet(pendingMap.keySet(), node);
550 for (NodeConnector nodeConnector : removeSet) {
551 pendingMap.remove(nodeConnector);
554 removeSet = getRemoveSet(edgeMap.keySet(), node);
555 for (NodeConnector nodeConnector : removeSet) {
556 removeEdge(nodeConnector, false);
559 removeSet = getRemoveSet(prodMap.keySet(), node);
560 for (NodeConnector nodeConnector : removeSet) {
561 removeProd(nodeConnector);
565 private void removeDiscovery(NodeConnector nodeConnector) {
566 readyListHi.remove(nodeConnector);
567 readyListLo.remove(nodeConnector);
568 waitingList.remove(nodeConnector);
569 pendingMap.remove(nodeConnector);
570 removeEdge(nodeConnector, false);
571 removeProd(nodeConnector);
574 private void checkTimeout() {
575 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
576 Set<NodeConnector> retrySet = new HashSet<NodeConnector>();
579 Set<NodeConnector> pendingSet = pendingMap.keySet();
580 if (pendingSet != null) {
581 for (NodeConnector nodeConnector : pendingSet) {
582 sentCount = pendingMap.get(nodeConnector);
583 pendingMap.put(nodeConnector, ++sentCount);
584 if (sentCount > getDiscoveryFinalTimeoutInterval()) {
586 removeSet.add(nodeConnector);
587 logger.trace("Discovery timeout {}", nodeConnector);
588 } else if (sentCount % discoveryTimeoutTicks == 0) {
589 retrySet.add(nodeConnector);
594 for (NodeConnector nodeConnector : removeSet) {
595 removeEdge(nodeConnector);
598 for (NodeConnector nodeConnector : retrySet) {
599 transmitQ.add(nodeConnector);
603 private void checkAging() {
604 if (!discoveryAgingEnabled) {
608 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
611 Set<NodeConnector> agingSet = agingMap.keySet();
612 if (agingSet != null) {
613 for (NodeConnector nodeConnector : agingSet) {
614 sentCount = agingMap.get(nodeConnector);
615 agingMap.put(nodeConnector, ++sentCount);
616 if (sentCount > discoveryAgeoutTicks) {
618 removeSet.add(nodeConnector);
619 logger.trace("Discovery age out {}", nodeConnector);
624 for (NodeConnector nodeConnector : removeSet) {
625 removeProd(nodeConnector);
629 private void doDiscovery() {
630 if (++discoveryTimerTickCount <= discoveryBatchPauseTicks) {
631 for (NodeConnector nodeConnector : getWorkingSet()) {
632 pendingMap.put(nodeConnector, 0);
633 transmitQ.add(nodeConnector);
635 } else if (discoveryTimerTickCount >= discoveryBatchRestartTicks) {
636 discoveryTimerTickCount = 0;
637 for (NodeConnector nodeConnector : waitingList) {
638 if (!readyListLo.contains(nodeConnector))
639 readyListLo.add(nodeConnector);
641 waitingList.removeAll(readyListLo);
645 private void doConsistencyCheck() {
646 if (!discoveryConsistencyCheckEnabled) {
650 if (++discoveryConsistencyCheckTickCount
651 % getDiscoveryConsistencyCheckInterval() != 0) {
655 discoveryConsistencyCheckCallingTimes++;
657 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
658 Set<NodeConnector> ncSet = edgeMap.keySet();
662 for (NodeConnector nodeConnector : ncSet) {
663 if (!isEnabled(nodeConnector)) {
664 removeSet.add(nodeConnector);
665 discoveryConsistencyCheckCorrected++;
666 logger.debug("ConsistencyChecker: remove disabled {}",
671 if (!isTracked(nodeConnector)) {
672 waitingList.add(nodeConnector);
673 discoveryConsistencyCheckCorrected++;
674 logger.debug("ConsistencyChecker: add back untracked {}",
680 for (NodeConnector nodeConnector : removeSet) {
681 removeEdge(nodeConnector, false);
684 // remove stale entries
686 for (NodeConnector nodeConnector : waitingList) {
687 if (!isEnabled(nodeConnector)) {
688 removeSet.add(nodeConnector);
689 discoveryConsistencyCheckCorrected++;
690 logger.debug("ConsistencyChecker: remove disabled {}",
694 waitingList.removeAll(removeSet);
696 // Get a snapshot of all the existing switches
697 Map<Long, ISwitch> switches = this.controller.getSwitches();
698 for (ISwitch sw : switches.values()) {
699 for (OFPhysicalPort port : sw.getEnabledPorts()) {
700 Node node = NodeCreator.createOFNode(sw.getId());
701 NodeConnector nodeConnector = NodeConnectorCreator
702 .createOFNodeConnector(port.getPortNumber(), node);
703 if (!isTracked(nodeConnector)) {
704 waitingList.add(nodeConnector);
705 discoveryConsistencyCheckCorrected++;
706 logger.debug("ConsistencyChecker: add back untracked {}",
713 private void addEdge(Edge edge, Set<Property> props) {
718 NodeConnector src = edge.getTailNodeConnector();
719 if (!src.getType().equals(
720 NodeConnector.NodeConnectorIDType.PRODUCTION)) {
721 pendingMap.remove(src);
722 if (!waitingList.contains(src)) {
723 waitingList.add(src);
726 NodeConnector dst = edge.getHeadNodeConnector();
727 agingMap.put(dst, 0);
730 // notify routeEngine
731 updateEdge(edge, UpdateType.ADDED, props);
732 logger.trace("Add edge {}", edge);
736 * Remove Production edge
738 private void removeProd(NodeConnector nodeConnector) {
739 agingMap.remove(nodeConnector);
742 Set<NodeConnector> prodKeySet = prodMap.keySet();
743 if ((prodKeySet != null) && (prodKeySet.contains(nodeConnector))) {
744 edge = prodMap.get(nodeConnector);
745 prodMap.remove(nodeConnector);
749 if (this.discoveryService != null) {
750 this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
752 logger.trace("Remove {}", nodeConnector);
756 * Remove OpenFlow edge
758 private void removeEdge(NodeConnector nodeConnector, boolean stillEnabled) {
759 pendingMap.remove(nodeConnector);
760 readyListLo.remove(nodeConnector);
761 readyListHi.remove(nodeConnector);
765 if (!waitingList.contains(nodeConnector)) {
766 waitingList.add(nodeConnector);
770 waitingList.remove(nodeConnector);
774 Set<NodeConnector> edgeKeySet = edgeMap.keySet();
775 if ((edgeKeySet != null) && (edgeKeySet.contains(nodeConnector))) {
776 edge = edgeMap.get(nodeConnector);
777 edgeMap.remove(nodeConnector);
781 if (this.discoveryService != null) {
782 this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
784 logger.trace("Remove {}", nodeConnector);
787 private void removeEdge(NodeConnector nodeConnector) {
788 removeEdge(nodeConnector, isEnabled(nodeConnector));
791 private void updateEdge(Edge edge, UpdateType type, Set<Property> props) {
792 if (discoveryService == null) {
796 this.discoveryService.notifyEdge(edge, type, props);
798 NodeConnector src = edge.getTailNodeConnector(), dst = edge
799 .getHeadNodeConnector();
800 if (!src.getType().equals(
801 NodeConnector.NodeConnectorIDType.PRODUCTION)) {
802 if (type == UpdateType.ADDED) {
803 edgeMap.put(src, edge);
809 * Save Production edge into different DB keyed by the Edge port
811 if (type == UpdateType.ADDED) {
812 prodMap.put(dst, edge);
819 private void moreToReadyListHi(NodeConnector nodeConnector) {
820 if (readyListLo.contains(nodeConnector)) {
821 readyListLo.remove(nodeConnector);
822 readyListHi.add(nodeConnector);
823 } else if (waitingList.contains(nodeConnector)) {
824 waitingList.remove(nodeConnector);
825 readyListHi.add(nodeConnector);
829 private void registerWithOSGIConsole() {
830 BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
832 bundleContext.registerService(CommandProvider.class.getName(), this,
836 private int getDiscoveryConsistencyCheckInterval() {
837 return discoveryConsistencyCheckMultiple * discoveryBatchRestartTicks;
840 private int getDiscoveryFinalTimeoutInterval() {
841 return (discoveryRetry + 1) * discoveryTimeoutTicks;
845 public String getHelp() {
846 StringBuffer help = new StringBuffer();
847 help.append("---Topology Discovery---\n");
848 help.append("\t prlh - Print readyListHi entries\n");
849 help.append("\t prll - Print readyListLo entries\n");
850 help.append("\t pwl - Print waitingList entries\n");
851 help.append("\t ppl - Print pendingList entries\n");
852 help.append("\t ptick - Print tick time in msec\n");
853 help.append("\t pcc - Print CC info\n");
855 .append("\t psize - Print sizes of all the lists\n");
856 help.append("\t ptm - Print timeout info\n");
857 help.append("\t ecc - Enable CC\n");
858 help.append("\t dcc - Disable CC\n");
860 .append("\t scc [multiple] - Set/show CC multiple and interval\n");
861 help.append("\t sports [ports] - Set/show max ports per batch\n");
862 help.append("\t spause [ticks] - Set/show pause ticks\n");
864 .append("\t sdi [ticks] - Set/show discovery interval in ticks\n");
865 help.append("\t stm [ticks] - Set/show per timeout ticks\n");
866 help.append("\t sretry [count] - Set/show num of retries\n");
867 help.append("\t addsw <swid> - Add a switch\n");
868 help.append("\t remsw <swid> - Remove a switch\n");
869 help.append("\t page - Print aging info\n");
870 help.append("\t sage - Set/Show aging time limit\n");
871 help.append("\t eage - Enable aging\n");
872 help.append("\t dage - Disable aging\n");
873 help.append("\t pthrot - Print throttling\n");
874 help.append("\t ethrot - Enable throttling\n");
875 help.append("\t dthrot - Disable throttling\n");
876 return help.toString();
879 public void _prlh(CommandInterpreter ci) {
880 ci.println("ReadyListHi\n");
881 for (NodeConnector nodeConnector : readyListHi) {
882 if (nodeConnector == null) {
885 ci.println(nodeConnector);
889 public void _prll(CommandInterpreter ci) {
890 ci.println("ReadyListLo\n");
891 for (NodeConnector nodeConnector : readyListLo) {
892 if (nodeConnector == null) {
895 ci.println(nodeConnector);
899 public void _pwl(CommandInterpreter ci) {
900 ci.println("WaitingList\n");
901 for (NodeConnector nodeConnector : waitingList) {
902 if (nodeConnector == null) {
905 ci.println(nodeConnector);
909 public void _ppl(CommandInterpreter ci) {
910 ci.println("PendingList\n");
911 for (NodeConnector nodeConnector : pendingMap.keySet()) {
912 if (nodeConnector == null) {
915 ci.println(nodeConnector);
919 public void _ptick(CommandInterpreter ci) {
920 ci.println("Current timer is " + discoveryTimerTick + " msec per tick");
923 public void _pcc(CommandInterpreter ci) {
924 if (discoveryConsistencyCheckEnabled) {
925 ci.println("ConsistencyChecker is currently enabled");
927 ci.println("ConsistencyChecker is currently disabled");
929 ci.println("Interval " + getDiscoveryConsistencyCheckInterval());
930 ci.println("Multiple " + discoveryConsistencyCheckMultiple);
931 ci.println("Number of times called "
932 + discoveryConsistencyCheckCallingTimes);
933 ci.println("Corrected count " + discoveryConsistencyCheckCorrected);
936 public void _ptm(CommandInterpreter ci) {
937 ci.println("Final timeout ticks " + getDiscoveryFinalTimeoutInterval());
938 ci.println("Per timeout ticks " + discoveryTimeoutTicks);
939 ci.println("Retry after initial timeout " + discoveryRetry);
942 public void _psize(CommandInterpreter ci) {
943 ci.println("readyListLo size " + readyListLo.size() + "\n"
944 + "readyListHi size " + readyListHi.size() + "\n"
945 + "waitingList size " + waitingList.size() + "\n"
946 + "pendingMap size " + pendingMap.size() + "\n"
947 + "edgeMap size " + edgeMap.size() + "\n" + "prodMap size "
948 + prodMap.size() + "\n" + "agingMap size " + agingMap.size());
951 public void _page(CommandInterpreter ci) {
952 if (this.discoveryAgingEnabled) {
953 ci.println("Aging is enabled");
955 ci.println("Aging is disabled");
957 ci.println("Current aging time limit " + this.discoveryAgeoutTicks);
960 .println(" Edge Aging ");
961 Collection<Edge> prodSet = prodMap.values();
962 if (prodSet == null) {
965 for (Edge edge : prodSet) {
966 Integer aging = agingMap.get(edge.getHeadNodeConnector());
968 ci.println(edge + " " + aging);
972 ci.println(" NodeConnector Edge ");
973 Set<NodeConnector> keySet = prodMap.keySet();
974 if (keySet == null) {
977 for (NodeConnector nc : keySet) {
978 ci.println(nc + " " + prodMap.get(nc));
983 public void _sage(CommandInterpreter ci) {
984 String val = ci.nextArgument();
986 ci.println("Please enter aging time limit. Current value "
987 + this.discoveryAgeoutTicks);
991 this.discoveryAgeoutTicks = Integer.parseInt(val);
992 } catch (Exception e) {
993 ci.println("Please enter a valid number");
998 public void _eage(CommandInterpreter ci) {
999 this.discoveryAgingEnabled = true;
1000 ci.println("Aging is enabled");
1004 public void _dage(CommandInterpreter ci) {
1005 this.discoveryAgingEnabled = false;
1006 ci.println("Aging is disabled");
1010 public void _scc(CommandInterpreter ci) {
1011 String val = ci.nextArgument();
1013 ci.println("Please enter CC multiple. Current multiple "
1014 + discoveryConsistencyCheckMultiple + " (interval "
1015 + getDiscoveryConsistencyCheckInterval()
1016 + ") calling times "
1017 + discoveryConsistencyCheckCallingTimes);
1021 discoveryConsistencyCheckMultiple = Integer.parseInt(val);
1022 } catch (Exception e) {
1023 ci.println("Please enter a valid number");
1028 public void _ecc(CommandInterpreter ci) {
1029 this.discoveryConsistencyCheckEnabled = true;
1030 ci.println("ConsistencyChecker is enabled");
1034 public void _dcc(CommandInterpreter ci) {
1035 this.discoveryConsistencyCheckEnabled = false;
1036 ci.println("ConsistencyChecker is disabled");
1040 public void _pspf(CommandInterpreter ci) {
1041 if (this.discoverySpoofingEnabled) {
1042 ci.println("Discovery spoofing is enabled");
1044 ci.println("Discovery spoofing is disabled");
1049 public void _espf(CommandInterpreter ci) {
1050 this.discoverySpoofingEnabled = true;
1051 ci.println("Discovery spoofing is enabled");
1055 public void _dspf(CommandInterpreter ci) {
1056 this.discoverySpoofingEnabled = false;
1057 ci.println("Discovery spoofing is disabled");
1061 public void _spause(CommandInterpreter ci) {
1062 String val = ci.nextArgument();
1063 String out = "Please enter pause tick value less than "
1064 + discoveryBatchRestartTicks + ". Current value is "
1065 + discoveryBatchPauseTicks;
1069 int pause = Integer.parseInt(val);
1070 if (pause < discoveryBatchRestartTicks) {
1071 discoveryBatchPauseTicks = pause;
1074 } catch (Exception e) {
1081 public void _sdi(CommandInterpreter ci) {
1082 String val = ci.nextArgument();
1085 .println("Please enter discovery interval in ticks. Current value is "
1086 + discoveryBatchRestartTicks);
1090 discoveryBatchRestartTicks = Integer.parseInt(val);
1091 } catch (Exception e) {
1092 ci.println("Please enter a valid number");
1097 public void _sports(CommandInterpreter ci) {
1098 String val = ci.nextArgument();
1100 ci.println("Please enter max ports per batch. Current value is "
1101 + discoveryBatchMaxPorts);
1105 discoveryBatchMaxPorts = Integer.parseInt(val);
1106 } catch (Exception e) {
1107 ci.println("Please enter a valid number");
1112 public void _sretry(CommandInterpreter ci) {
1113 String val = ci.nextArgument();
1115 ci.println("Please enter number of retries. Current value is "
1120 discoveryRetry = Integer.parseInt(val);
1121 } catch (Exception e) {
1122 ci.println("Please enter a valid number");
1127 public void _stm(CommandInterpreter ci) {
1128 String val = ci.nextArgument();
1129 String out = "Please enter timeout tick value less than "
1130 + discoveryBatchRestartTicks + ". Current value is "
1131 + discoveryTimeoutTicks;
1134 int timeout = Integer.parseInt(val);
1135 if (timeout < discoveryBatchRestartTicks) {
1136 discoveryTimeoutTicks = timeout;
1139 } catch (Exception e) {
1146 public void _addsw(CommandInterpreter ci) {
1147 String val = ci.nextArgument();
1150 sid = Long.parseLong(val);
1151 Node node = NodeCreator.createOFNode(sid);
1153 } catch (Exception e) {
1154 ci.println("Please enter a valid number");
1159 public void _remsw(CommandInterpreter ci) {
1160 String val = ci.nextArgument();
1163 sid = Long.parseLong(val);
1164 Node node = NodeCreator.createOFNode(sid);
1165 removeDiscovery(node);
1166 } catch (Exception e) {
1167 ci.println("Please enter a valid number");
1172 public void _pthrot(CommandInterpreter ci) {
1173 if (this.throttling) {
1174 ci.println("Throttling is enabled");
1176 ci.println("Throttling is disabled");
1180 public void _ethrot(CommandInterpreter ci) {
1181 this.throttling = true;
1182 ci.println("Throttling is enabled");
1186 public void _dthrot(CommandInterpreter ci) {
1187 this.throttling = false;
1188 ci.println("Throttling is disabled");
1193 public void updateNode(Node node, UpdateType type, Set<Property> props) {
1196 addNode(node, props);
1207 public void updateNodeConnector(NodeConnector nodeConnector,
1208 UpdateType type, Set<Property> props) {
1209 Config config = null;
1211 boolean enabled = false;
1213 for (Property prop : props) {
1214 if (prop.getName().equals(Config.ConfigPropName)) {
1215 config = (Config) prop;
1216 } else if (prop.getName().equals(State.StatePropName)) {
1217 state = (State) prop;
1220 enabled = ((config != null) && (config.getValue() == Config.ADMIN_UP)
1221 && (state != null) && (state.getValue() == State.EDGE_UP));
1226 addDiscovery(nodeConnector);
1227 logger.trace("ADDED enabled {}", nodeConnector);
1229 logger.trace("ADDED disabled {}", nodeConnector);
1234 addDiscovery(nodeConnector);
1235 logger.trace("CHANGED enabled {}", nodeConnector);
1237 removeDiscovery(nodeConnector);
1238 logger.trace("CHANGED disabled {}", nodeConnector);
1242 removeDiscovery(nodeConnector);
1243 logger.trace("REMOVED enabled {}", nodeConnector);
1250 public void addNode(Node node, Set<Property> props) {
1257 public void removeNode(Node node) {
1261 removeDiscovery(node);
1264 public void updateNode(Node node, Set<Property> props) {
1267 void setController(IController s) {
1268 this.controller = s;
1271 void unsetController(IController s) {
1272 if (this.controller == s) {
1273 this.controller = null;
1277 public void setPluginInInventoryService(IPluginInInventoryService service) {
1278 this.pluginInInventoryService = service;
1281 public void unsetPluginInInventoryService(IPluginInInventoryService service) {
1282 this.pluginInInventoryService = null;
1285 public void setIDataPacketMux(IDataPacketMux service) {
1286 this.iDataPacketMux = service;
1289 public void unsetIDataPacketMux(IDataPacketMux service) {
1290 if (this.iDataPacketMux == service) {
1291 this.iDataPacketMux = null;
1295 void setDiscoveryService(IDiscoveryService s) {
1296 this.discoveryService = s;
1299 void unsetDiscoveryService(IDiscoveryService s) {
1300 if (this.discoveryService == s) {
1301 this.discoveryService = null;
1305 private void initDiscoveryPacket() {
1306 // Create LLDP ChassisID TLV
1307 chassisIdTlv = new LLDPTLV();
1308 chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue());
1310 // Create LLDP PortID TLV
1311 portIdTlv = new LLDPTLV();
1312 portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue());
1314 // Create LLDP TTL TLV
1315 byte[] ttl = new byte[] { (byte) 120 };
1316 ttlTlv = new LLDPTLV();
1317 ttlTlv.setType((byte) LLDPTLV.TLVType.TTL.getValue()).setLength(
1318 (short) ttl.length).setValue(ttl);
1320 customTlv = new LLDPTLV();
1324 * Function called by the dependency manager when all the required
1325 * dependencies are satisfied
1329 logger.trace("Init called");
1331 transmitQ = new LinkedBlockingQueue<NodeConnector>();
1333 readyListHi = new CopyOnWriteArrayList<NodeConnector>();
1334 readyListLo = new CopyOnWriteArrayList<NodeConnector>();
1335 waitingList = new CopyOnWriteArrayList<NodeConnector>();
1336 pendingMap = new ConcurrentHashMap<NodeConnector, Integer>();
1337 edgeMap = new ConcurrentHashMap<NodeConnector, Edge>();
1338 agingMap = new ConcurrentHashMap<NodeConnector, Integer>();
1339 prodMap = new ConcurrentHashMap<NodeConnector, Edge>();
1341 discoveryTimer = new Timer("DiscoveryService");
1342 discoveryTimerTask = new DiscoveryTimerTask();
1344 transmitThread = new Thread(new DiscoveryTransmit(transmitQ));
1346 initDiscoveryPacket();
1348 registerWithOSGIConsole();
1352 * Function called by the dependency manager when at least one dependency
1353 * become unsatisfied or when the component is shutting down because for
1354 * example bundle is being stopped.
1366 discoveryTimer = null;
1367 discoveryTimerTask = null;
1368 transmitThread = null;
1372 * Function called by dependency manager after "init ()" is called and after
1373 * the services provided by the class are registered in the service registry
1377 discoveryTimer.schedule(discoveryTimerTask, discoveryTimerTick,
1378 discoveryTimerTick);
1379 transmitThread.start();
1383 * Function called after registering the
1384 * service in OSGi service registry.
1387 /* get a snapshot of all the existing switches */
1392 * Function called by the dependency manager before the services exported by
1393 * the component are unregistered, this will be followed by a "destroy ()"
1398 shuttingDown = true;
1399 discoveryTimer.cancel();
1400 transmitThread.interrupt();
1404 public void tagUpdated(String containerName, Node n, short oldTag,
1405 short newTag, UpdateType t) {
1409 public void containerFlowUpdated(String containerName,
1410 ContainerFlow previousFlow, ContainerFlow currentFlow, UpdateType t) {
1414 public void nodeConnectorUpdated(String containerName, NodeConnector p,
1418 moreToReadyListHi(p);
1426 public void containerModeUpdated(UpdateType t) {
1430 private byte[] getSouceMACFromNodeID(String nodeId) {
1431 byte[] cid = HexEncode.bytesFromHexString(nodeId);
1432 byte[] sourceMac = new byte[6];
1433 int pos = cid.length - sourceMac.length;
1436 System.arraycopy(cid, pos, sourceMac, 0, sourceMac.length);