2 * Copyright (c) 2013 Cisco Systems, Inc. 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.controller.protocol_plugin.openflow.internal;
11 import java.util.ArrayList;
12 import java.util.Collection;
13 import java.util.HashSet;
14 import java.util.List;
17 import java.util.Timer;
18 import java.util.TimerTask;
19 import java.util.concurrent.BlockingQueue;
20 import java.util.concurrent.ConcurrentHashMap;
21 import java.util.concurrent.ConcurrentMap;
22 import java.util.concurrent.CopyOnWriteArrayList;
23 import java.util.concurrent.LinkedBlockingQueue;
25 import org.eclipse.osgi.framework.console.CommandInterpreter;
26 import org.eclipse.osgi.framework.console.CommandProvider;
27 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketListen;
28 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketMux;
29 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimExternalListener;
30 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
31 import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
32 import org.openflow.protocol.OFPhysicalPort;
33 import org.osgi.framework.BundleContext;
34 import org.osgi.framework.FrameworkUtil;
35 import org.slf4j.Logger;
36 import org.slf4j.LoggerFactory;
38 import org.opendaylight.controller.sal.core.Config;
39 import org.opendaylight.controller.sal.core.ConstructionException;
40 import org.opendaylight.controller.sal.core.Edge;
41 import org.opendaylight.controller.sal.core.ContainerFlow;
42 import org.opendaylight.controller.sal.core.IContainerListener;
43 import org.opendaylight.controller.sal.core.Node;
44 import org.opendaylight.controller.sal.core.NodeConnector;
45 import org.opendaylight.controller.sal.core.Property;
46 import org.opendaylight.controller.sal.core.State;
47 import org.opendaylight.controller.sal.core.UpdateType;
48 import org.opendaylight.controller.sal.discovery.IDiscoveryService;
49 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
50 import org.opendaylight.controller.sal.packet.Ethernet;
51 import org.opendaylight.controller.sal.packet.LLDP;
52 import org.opendaylight.controller.sal.packet.LLDPTLV;
53 import org.opendaylight.controller.sal.packet.LinkEncap;
54 import org.opendaylight.controller.sal.packet.PacketResult;
55 import org.opendaylight.controller.sal.packet.RawPacket;
56 import org.opendaylight.controller.sal.utils.EtherTypes;
57 import org.opendaylight.controller.sal.utils.HexEncode;
58 import org.opendaylight.controller.sal.utils.NetUtils;
59 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
60 import org.opendaylight.controller.sal.utils.NodeCreator;
63 * The class describes neighbor discovery service for an OpenFlow network.
65 public class DiscoveryService implements IInventoryShimExternalListener,
66 IDataPacketListen, IContainerListener, CommandProvider {
67 private static Logger logger = LoggerFactory
68 .getLogger(DiscoveryService.class);
69 private IController controller = null;
70 private IDiscoveryService discoveryService = null;
71 private IPluginInInventoryService pluginInInventoryService = null;
72 private IDataPacketMux iDataPacketMux = null;
74 private List<NodeConnector> readyListHi = null; // newly added ports go into
75 // this list and will be
77 private List<NodeConnector> readyListLo = null; // come here after served at
79 private List<NodeConnector> waitingList = null; // staging area during quiet
81 private ConcurrentMap<NodeConnector, Integer> pendingMap = null;// wait for
84 private ConcurrentMap<NodeConnector, Edge> edgeMap = null; // openflow edges
87 private ConcurrentMap<NodeConnector, Integer> agingMap = null; // aging
91 private ConcurrentMap<NodeConnector, Edge> prodMap = null; // production
95 private Timer discoveryTimer; // discovery timer
96 private DiscoveryTimerTask discoveryTimerTask; // timer task
97 private long discoveryTimerTick = 1L * 1000; // per tick in msec
98 private int discoveryTimerTickCount = 0; // main tick counter
99 private int discoveryBatchMaxPorts = 500; // max # of ports handled in one
101 private int discoveryBatchRestartTicks = getDiscoveryInterval(); // periodically
105 private int discoveryBatchPausePeriod = 5; // pause for few secs
106 private int discoveryBatchPauseTicks = discoveryBatchRestartTicks
107 - discoveryBatchPausePeriod; // pause after this point
108 private int discoveryRetry = getDiscoveryRetry(); // number of retries after
110 private int discoveryTimeoutTicks = getDiscoveryTimeout(); // timeout in sec
111 private int discoveryAgeoutTicks = 120; // age out 2 min
112 private int discoveryConsistencyCheckMultiple = 2; // multiple of
113 // discoveryBatchRestartTicks
114 private int discoveryConsistencyCheckTickCount = discoveryBatchPauseTicks; // CC
117 private int discoveryConsistencyCheckCallingTimes = 0; // # of times CC gets
119 private int discoveryConsistencyCheckCorrected = 0; // # of cases CC
121 private boolean discoveryConsistencyCheckEnabled = true;// enable or disable
123 private boolean discoveryAgingEnabled = true; // enable or disable aging
124 private boolean discoverySnoopingEnabled = true; // global flag to enable or
125 // disable LLDP snooping
126 private List<NodeConnector> discoverySnoopingDisableList; // the list of
130 private BlockingQueue<NodeConnector> transmitQ;
131 private Thread transmitThread;
132 private Boolean throttling = false; // if true, no more batching.
133 private volatile Boolean shuttingDown = false;
135 private LLDPTLV chassisIdTlv, portIdTlv, ttlTlv, customTlv;
137 class DiscoveryTransmit implements Runnable {
138 private final BlockingQueue<NodeConnector> transmitQ;
140 DiscoveryTransmit(BlockingQueue<NodeConnector> transmitQ) {
141 this.transmitQ = transmitQ;
147 NodeConnector nodeConnector = transmitQ.take();
148 RawPacket outPkt = createDiscoveryPacket(nodeConnector);
149 sendDiscoveryPacket(nodeConnector, outPkt);
150 nodeConnector = null;
151 } catch (InterruptedException e1) {
152 logger.warn("DiscoveryTransmit interupted", e1.getMessage());
155 } catch (Exception e2) {
156 logger.error("", e2);
162 class DiscoveryTimerTask extends TimerTask {
166 doConsistencyCheck();
171 private RawPacket createDiscoveryPacket(NodeConnector nodeConnector) {
172 String nodeId = HexEncode.longToHexString((Long) nodeConnector
175 // Create LLDP ChassisID TLV
176 byte[] cidValue = LLDPTLV.createChassisIDTLVValue(nodeId);
177 chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue())
178 .setLength((short) cidValue.length).setValue(cidValue);
180 // Create LLDP PortID TLV
181 String portId = nodeConnector.getNodeConnectorIDString();
182 byte[] pidValue = LLDPTLV.createPortIDTLVValue(portId);
183 portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue())
184 .setLength((short) pidValue.length).setValue(pidValue);
186 // Create LLDP Custom TLV
187 byte[] customValue = LLDPTLV.createCustomTLVValue(nodeConnector
189 customTlv.setType((byte) LLDPTLV.TLVType.Custom.getValue())
190 .setLength((short) customValue.length).setValue(customValue);
192 // Create LLDP Custom Option list
193 List<LLDPTLV> customList = new ArrayList<LLDPTLV>();
194 customList.add(customTlv);
196 // Create discovery pkt
197 LLDP discoveryPkt = new LLDP();
198 discoveryPkt.setChassisId(chassisIdTlv).setPortId(portIdTlv)
199 .setTtl(ttlTlv).setOptionalTLVList(customList);
201 RawPacket rawPkt = null;
203 // Create ethernet pkt
204 byte[] sourceMac = getSouceMACFromNodeID(nodeId);
205 Ethernet ethPkt = new Ethernet();
206 ethPkt.setSourceMACAddress(sourceMac)
207 .setDestinationMACAddress(LLDP.LLDPMulticastMac)
208 .setEtherType(EtherTypes.LLDP.shortValue())
209 .setPayload(discoveryPkt);
211 byte[] data = ethPkt.serialize();
212 rawPkt = new RawPacket(data);
213 rawPkt.setOutgoingNodeConnector(nodeConnector);
214 } catch (ConstructionException cex) {
215 logger.warn("RawPacket creation caught exception {}",
217 } catch (Exception e) {
218 logger.error("Failed to serialize the LLDP packet: " + e);
224 private void sendDiscoveryPacket(NodeConnector nodeConnector,
226 if (nodeConnector == null) {
227 logger.debug("Can not send discovery packet out since nodeConnector is null");
231 if (outPkt == null) {
232 logger.debug("Can not send discovery packet out since outPkt is null");
236 long sid = (Long) nodeConnector.getNode().getID();
237 ISwitch sw = controller.getSwitches().get(sid);
241 "Can not send discovery packet out since switch {} is null",
246 if (!sw.isOperational()) {
248 "Can not send discovery packet out since switch {} is not operational",
253 if (this.iDataPacketMux == null) {
254 logger.debug("Can not send discovery packet out since DataPacket service is not available");
258 logger.trace("Sending topology discovery pkt thru {}", nodeConnector);
259 this.iDataPacketMux.transmitDataPacket(outPkt);
263 public PacketResult receiveDataPacket(RawPacket inPkt) {
265 logger.debug("Ignoring null packet");
266 return PacketResult.IGNORED;
269 byte[] data = inPkt.getPacketData();
270 if (data.length <= 0) {
271 logger.trace("Ignoring zero length packet");
272 return PacketResult.IGNORED;
275 if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) {
276 logger.trace("Ignoring non ethernet packet");
277 return PacketResult.IGNORED;
280 if (((Short) inPkt.getIncomingNodeConnector().getID())
281 .equals(NodeConnector.SPECIALNODECONNECTORID)) {
282 logger.trace("Ignoring ethernet packet received on special port: "
283 + inPkt.getIncomingNodeConnector().toString());
284 return PacketResult.IGNORED;
287 Ethernet ethPkt = new Ethernet();
289 ethPkt.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
290 } catch (Exception e) {
291 logger.warn("Failed to decode LLDP packet from {}: {}",
292 inPkt.getIncomingNodeConnector(), e);
293 return PacketResult.IGNORED;
295 if (ethPkt.getPayload() instanceof LLDP) {
296 NodeConnector dst = inPkt.getIncomingNodeConnector();
297 if (!processDiscoveryPacket(dst, ethPkt)) {
298 /* Snoop the discovery pkt if not generated from us */
299 snoopDiscoveryPacket(dst, ethPkt);
301 return PacketResult.CONSUME;
303 return PacketResult.IGNORED;
307 * Snoop incoming discovery frames generated by the production network
310 private void snoopDiscoveryPacket(NodeConnector dstNodeConnector,
312 if (!this.discoverySnoopingEnabled
313 || discoverySnoopingDisableList.contains(dstNodeConnector)) {
315 "Discarded received discovery packet on {} since snooping is turned off",
320 if ((dstNodeConnector == null) || (ethPkt == null)) {
321 logger.trace("Quit snooping discovery packet: Null node connector or packet");
325 LLDP lldp = (LLDP) ethPkt.getPayload();
328 String nodeId = LLDPTLV.getHexStringValue(lldp.getChassisId()
329 .getValue(), lldp.getChassisId().getLength());
330 String portId = LLDPTLV.getStringValue(lldp.getPortId().getValue(),
331 lldp.getPortId().getLength());
332 byte[] systemNameBytes = null;
333 // get system name if present in the LLDP pkt
334 for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) {
335 if (lldptlv.getType() == LLDPTLV.TLVType.SystemName.getValue()) {
336 systemNameBytes = lldptlv.getValue();
340 String nodeName = (systemNameBytes == null) ? nodeId : new String(
342 Node srcNode = new Node(Node.NodeIDType.PRODUCTION, nodeName);
343 NodeConnector srcNodeConnector = NodeConnectorCreator
344 .createNodeConnector(
345 NodeConnector.NodeConnectorIDType.PRODUCTION,
349 Set<Property> props = null;
350 edge = new Edge(srcNodeConnector, dstNodeConnector);
351 props = getProps(dstNodeConnector);
353 updateProdEdge(edge, props);
354 } catch (Exception e) {
355 logger.warn("Caught exception ", e);
360 * Handle discovery frames generated by our controller
362 * @return true if it's a success
364 private boolean processDiscoveryPacket(NodeConnector dstNodeConnector,
366 if ((dstNodeConnector == null) || (ethPkt == null)) {
367 logger.trace("Ignoring processing of discovery packet: Null node connector or packet");
371 logger.trace("Handle discovery packet {} from {}", ethPkt,
374 LLDP lldp = (LLDP) ethPkt.getPayload();
376 List<LLDPTLV> optionalTLVList = lldp.getOptionalTLVList();
377 if (optionalTLVList == null) {
378 logger.info("The discovery packet with null custom option from {}",
384 NodeConnector srcNodeConnector = null;
385 for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) {
386 if (lldptlv.getType() == LLDPTLV.TLVType.Custom.getValue()) {
387 String ncString = LLDPTLV.getCustomString(lldptlv.getValue(),
388 lldptlv.getLength());
389 srcNodeConnector = NodeConnector.fromString(ncString);
390 if (srcNodeConnector != null) {
391 srcNode = srcNodeConnector.getNode();
392 /* Check if it's expected */
393 if (isTracked(srcNodeConnector)) {
397 srcNodeConnector = null;
403 if ((srcNode == null) || (srcNodeConnector == null)) {
405 "Received non-controller generated discovery packet from {}",
410 // push it out to Topology
412 Set<Property> props = null;
414 edge = new Edge(srcNodeConnector, dstNodeConnector);
415 props = getProps(dstNodeConnector);
416 } catch (ConstructionException e) {
417 logger.error("Caught exception ", e);
419 addEdge(edge, props);
421 logger.trace("Received discovery packet for Edge {}", edge);
426 public Map<String, Property> getPropMap(NodeConnector nodeConnector) {
427 if (nodeConnector == null) {
431 if (pluginInInventoryService == null) {
435 Map<NodeConnector, Map<String, Property>> props = pluginInInventoryService
436 .getNodeConnectorProps(false);
441 return props.get(nodeConnector);
444 public Property getProp(NodeConnector nodeConnector, String propName) {
445 Map<String, Property> propMap = getPropMap(nodeConnector);
446 if (propMap == null) {
450 Property prop = (Property) propMap.get(propName);
454 public Set<Property> getProps(NodeConnector nodeConnector) {
455 Map<String, Property> propMap = getPropMap(nodeConnector);
456 if (propMap == null) {
460 Set<Property> props = new HashSet<Property>(propMap.values());
464 private boolean isEnabled(NodeConnector nodeConnector) {
465 if (nodeConnector == null) {
469 Config config = (Config) getProp(nodeConnector, Config.ConfigPropName);
470 State state = (State) getProp(nodeConnector, State.StatePropName);
471 return ((config != null) && (config.getValue() == Config.ADMIN_UP)
472 && (state != null) && (state.getValue() == State.EDGE_UP));
475 private boolean isTracked(NodeConnector nodeConnector) {
476 if (readyListHi.contains(nodeConnector)) {
480 if (readyListLo.contains(nodeConnector)) {
484 if (pendingMap.keySet().contains(nodeConnector)) {
488 if (waitingList.contains(nodeConnector)) {
495 private Set<NodeConnector> getWorkingSet() {
496 Set<NodeConnector> workingSet = new HashSet<NodeConnector>();
497 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
499 for (NodeConnector nodeConnector : readyListHi) {
500 if (isOverLimit(workingSet.size())) {
504 workingSet.add(nodeConnector);
505 removeSet.add(nodeConnector);
507 readyListHi.removeAll(removeSet);
510 for (NodeConnector nodeConnector : readyListLo) {
511 if (isOverLimit(workingSet.size())) {
515 workingSet.add(nodeConnector);
516 removeSet.add(nodeConnector);
518 readyListLo.removeAll(removeSet);
523 private Boolean isOverLimit(int size) {
524 return ((size >= discoveryBatchMaxPorts) && !throttling);
527 private void addDiscovery() {
528 Map<Long, ISwitch> switches = controller.getSwitches();
529 Set<Long> sidSet = switches.keySet();
530 if (sidSet == null) {
533 for (Long sid : sidSet) {
534 Node node = NodeCreator.createOFNode(sid);
539 private void addDiscovery(Node node) {
540 Map<Long, ISwitch> switches = controller.getSwitches();
541 ISwitch sw = switches.get((Long) node.getID());
542 List<OFPhysicalPort> ports = sw.getEnabledPorts();
546 for (OFPhysicalPort port : ports) {
547 NodeConnector nodeConnector = NodeConnectorCreator
548 .createOFNodeConnector(port.getPortNumber(), node);
549 if (!readyListHi.contains(nodeConnector)) {
550 readyListHi.add(nodeConnector);
555 private void addDiscovery(NodeConnector nodeConnector) {
556 if (isTracked(nodeConnector)) {
560 readyListHi.add(nodeConnector);
563 private Set<NodeConnector> getRemoveSet(Collection<NodeConnector> c,
565 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
569 for (NodeConnector nodeConnector : c) {
570 if (node.equals(nodeConnector.getNode())) {
571 removeSet.add(nodeConnector);
577 private void removeDiscovery(Node node) {
578 Set<NodeConnector> removeSet;
580 removeSet = getRemoveSet(readyListHi, node);
581 readyListHi.removeAll(removeSet);
583 removeSet = getRemoveSet(readyListLo, node);
584 readyListLo.removeAll(removeSet);
586 removeSet = getRemoveSet(waitingList, node);
587 waitingList.removeAll(removeSet);
589 removeSet = getRemoveSet(pendingMap.keySet(), node);
590 for (NodeConnector nodeConnector : removeSet) {
591 pendingMap.remove(nodeConnector);
594 removeSet = getRemoveSet(edgeMap.keySet(), node);
595 for (NodeConnector nodeConnector : removeSet) {
596 removeEdge(nodeConnector, false);
599 removeSet = getRemoveSet(prodMap.keySet(), node);
600 for (NodeConnector nodeConnector : removeSet) {
601 removeProdEdge(nodeConnector);
605 private void removeDiscovery(NodeConnector nodeConnector) {
606 readyListHi.remove(nodeConnector);
607 readyListLo.remove(nodeConnector);
608 waitingList.remove(nodeConnector);
609 pendingMap.remove(nodeConnector);
610 removeEdge(nodeConnector, false);
611 removeProdEdge(nodeConnector);
614 private void checkTimeout() {
615 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
616 Set<NodeConnector> retrySet = new HashSet<NodeConnector>();
619 Set<NodeConnector> pendingSet = pendingMap.keySet();
620 if (pendingSet != null) {
621 for (NodeConnector nodeConnector : pendingSet) {
622 sentCount = pendingMap.get(nodeConnector);
623 pendingMap.put(nodeConnector, ++sentCount);
624 if (sentCount > getDiscoveryFinalTimeoutInterval()) {
626 removeSet.add(nodeConnector);
627 logger.trace("Discovery timeout {}", nodeConnector);
628 } else if (sentCount % discoveryTimeoutTicks == 0) {
629 retrySet.add(nodeConnector);
634 for (NodeConnector nodeConnector : removeSet) {
635 removeEdge(nodeConnector);
638 for (NodeConnector nodeConnector : retrySet) {
639 transmitQ.add(nodeConnector);
643 private void checkAging() {
644 if (!discoveryAgingEnabled) {
648 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
651 Set<NodeConnector> agingSet = agingMap.keySet();
652 if (agingSet != null) {
653 for (NodeConnector nodeConnector : agingSet) {
654 sentCount = agingMap.get(nodeConnector);
655 agingMap.put(nodeConnector, ++sentCount);
656 if (sentCount > discoveryAgeoutTicks) {
658 removeSet.add(nodeConnector);
659 logger.trace("Discovery age out {}", nodeConnector);
664 for (NodeConnector nodeConnector : removeSet) {
665 removeProdEdge(nodeConnector);
669 private void doDiscovery() {
670 if (++discoveryTimerTickCount <= discoveryBatchPauseTicks) {
671 for (NodeConnector nodeConnector : getWorkingSet()) {
672 pendingMap.put(nodeConnector, 0);
673 transmitQ.add(nodeConnector);
675 } else if (discoveryTimerTickCount >= discoveryBatchRestartTicks) {
676 discoveryTimerTickCount = 0;
677 for (NodeConnector nodeConnector : waitingList) {
678 if (!readyListLo.contains(nodeConnector))
679 readyListLo.add(nodeConnector);
681 waitingList.removeAll(readyListLo);
685 private void doConsistencyCheck() {
686 if (!discoveryConsistencyCheckEnabled) {
690 if (++discoveryConsistencyCheckTickCount
691 % getDiscoveryConsistencyCheckInterval() != 0) {
695 discoveryConsistencyCheckCallingTimes++;
697 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
698 Set<NodeConnector> ncSet = edgeMap.keySet();
702 for (NodeConnector nodeConnector : ncSet) {
703 if (!isEnabled(nodeConnector)) {
704 removeSet.add(nodeConnector);
705 discoveryConsistencyCheckCorrected++;
706 logger.debug("ConsistencyChecker: remove disabled {}",
711 if (!isTracked(nodeConnector)) {
712 waitingList.add(nodeConnector);
713 discoveryConsistencyCheckCorrected++;
714 logger.debug("ConsistencyChecker: add back untracked {}",
720 for (NodeConnector nodeConnector : removeSet) {
721 removeEdge(nodeConnector, false);
724 // remove stale entries
726 for (NodeConnector nodeConnector : waitingList) {
727 if (!isEnabled(nodeConnector)) {
728 removeSet.add(nodeConnector);
729 discoveryConsistencyCheckCorrected++;
730 logger.debug("ConsistencyChecker: remove disabled {}",
734 waitingList.removeAll(removeSet);
736 // Get a snapshot of all the existing switches
737 Map<Long, ISwitch> switches = this.controller.getSwitches();
738 for (ISwitch sw : switches.values()) {
739 for (OFPhysicalPort port : sw.getEnabledPorts()) {
740 Node node = NodeCreator.createOFNode(sw.getId());
741 NodeConnector nodeConnector = NodeConnectorCreator
742 .createOFNodeConnector(port.getPortNumber(), node);
743 if (!isTracked(nodeConnector)) {
744 waitingList.add(nodeConnector);
745 discoveryConsistencyCheckCorrected++;
746 logger.debug("ConsistencyChecker: add back untracked {}",
753 private void addEdge(Edge edge, Set<Property> props) {
758 NodeConnector src = edge.getTailNodeConnector();
759 if (!src.getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
760 pendingMap.remove(src);
761 if (!waitingList.contains(src)) {
762 waitingList.add(src);
765 NodeConnector dst = edge.getHeadNodeConnector();
766 agingMap.put(dst, 0);
769 // notify routeEngine
770 updateEdge(edge, UpdateType.ADDED, props);
771 logger.trace("Add edge {}", edge);
775 * Update Production Edge
778 * The Production Edge
780 * Properties associated with the edge
782 private void updateProdEdge(Edge edge, Set<Property> props) {
783 NodeConnector edgePort = edge.getHeadNodeConnector();
785 /* Do not update in case there is an existing OpenFlow link */
786 if (edgeMap.get(edgePort) != null) {
788 "Discarded edge {} since there is an existing OF link {}",
789 edge, edgeMap.get(edgePort));
793 /* Look for any existing Production Edge */
794 Edge oldEdge = prodMap.get(edgePort);
795 if (oldEdge == null) {
796 /* Let's add a new one */
797 addEdge(edge, props);
798 } else if (!edge.equals(oldEdge)) {
799 /* Remove the old one first */
800 removeProdEdge(oldEdge.getHeadNodeConnector());
801 /* Then add the new one */
802 addEdge(edge, props);
804 /* o/w, just reset the aging timer */
805 NodeConnector dst = edge.getHeadNodeConnector();
806 agingMap.put(dst, 0);
811 * Remove Production Edge for a given edge port
816 private void removeProdEdge(NodeConnector edgePort) {
817 agingMap.remove(edgePort);
820 Set<NodeConnector> prodKeySet = prodMap.keySet();
821 if ((prodKeySet != null) && (prodKeySet.contains(edgePort))) {
822 edge = prodMap.get(edgePort);
823 prodMap.remove(edgePort);
827 if (this.discoveryService != null) {
828 this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
830 logger.trace("Remove edge {}", edge);
834 * Remove OpenFlow edge
836 private void removeEdge(NodeConnector nodeConnector, boolean stillEnabled) {
837 pendingMap.remove(nodeConnector);
838 readyListLo.remove(nodeConnector);
839 readyListHi.remove(nodeConnector);
843 if (!waitingList.contains(nodeConnector)) {
844 waitingList.add(nodeConnector);
848 waitingList.remove(nodeConnector);
852 Set<NodeConnector> edgeKeySet = edgeMap.keySet();
853 if ((edgeKeySet != null) && (edgeKeySet.contains(nodeConnector))) {
854 edge = edgeMap.get(nodeConnector);
855 edgeMap.remove(nodeConnector);
859 if (this.discoveryService != null) {
860 this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
862 logger.trace("Remove {}", nodeConnector);
865 private void removeEdge(NodeConnector nodeConnector) {
866 removeEdge(nodeConnector, isEnabled(nodeConnector));
869 private void updateEdge(Edge edge, UpdateType type, Set<Property> props) {
870 if (discoveryService == null) {
874 this.discoveryService.notifyEdge(edge, type, props);
876 NodeConnector src = edge.getTailNodeConnector(), dst = edge
877 .getHeadNodeConnector();
878 if (!src.getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
879 if (type == UpdateType.ADDED) {
880 edgeMap.put(dst, edge);
886 * Save Production edge into different DB keyed by the Edge port
888 if (type == UpdateType.ADDED) {
889 prodMap.put(dst, edge);
896 private void moreToReadyListHi(NodeConnector nodeConnector) {
897 if (readyListLo.contains(nodeConnector)) {
898 readyListLo.remove(nodeConnector);
899 readyListHi.add(nodeConnector);
900 } else if (waitingList.contains(nodeConnector)) {
901 waitingList.remove(nodeConnector);
902 readyListHi.add(nodeConnector);
906 private void registerWithOSGIConsole() {
907 BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
909 bundleContext.registerService(CommandProvider.class.getName(), this,
913 private int getDiscoveryConsistencyCheckInterval() {
914 return discoveryConsistencyCheckMultiple * discoveryBatchRestartTicks;
917 private int getDiscoveryFinalTimeoutInterval() {
918 return (discoveryRetry + 1) * discoveryTimeoutTicks;
922 public String getHelp() {
923 StringBuffer help = new StringBuffer();
924 help.append("---Topology Discovery---\n");
925 help.append("\t prlh - Print readyListHi entries\n");
926 help.append("\t prll - Print readyListLo entries\n");
927 help.append("\t pwl - Print waitingList entries\n");
928 help.append("\t ppl - Print pendingList entries\n");
929 help.append("\t ptick - Print tick time in msec\n");
930 help.append("\t pcc - Print CC info\n");
931 help.append("\t psize - Print sizes of all the lists\n");
932 help.append("\t ptm - Print timeout info\n");
933 help.append("\t ecc - Enable CC\n");
934 help.append("\t dcc - Disable CC\n");
935 help.append("\t scc [multiple] - Set/show CC multiple and interval\n");
936 help.append("\t sports [ports] - Set/show max ports per batch\n");
937 help.append("\t spause [ticks] - Set/show pause period\n");
938 help.append("\t sdi [ticks] - Set/show discovery interval in ticks\n");
939 help.append("\t stm [ticks] - Set/show per timeout ticks\n");
940 help.append("\t sretry [count] - Set/show num of retries\n");
941 help.append("\t addsw <swid> - Add a switch\n");
942 help.append("\t remsw <swid> - Remove a switch\n");
943 help.append("\t page - Print aging info\n");
944 help.append("\t sage - Set/Show aging time limit\n");
945 help.append("\t eage - Enable aging\n");
946 help.append("\t dage - Disable aging\n");
947 help.append("\t pthrot - Print throttling\n");
948 help.append("\t ethrot - Enable throttling\n");
949 help.append("\t dthrot - Disable throttling\n");
950 help.append("\t psnp - Print LLDP snooping\n");
951 help.append("\t esnp <all|nodeConnector> - Enable LLDP snooping\n");
952 help.append("\t dsnp <all|nodeConnector> - Disable LLDP snooping\n");
953 return help.toString();
956 public void _prlh(CommandInterpreter ci) {
957 ci.println("ReadyListHi\n");
958 for (NodeConnector nodeConnector : readyListHi) {
959 if (nodeConnector == null) {
962 ci.println(nodeConnector);
966 public void _prll(CommandInterpreter ci) {
967 ci.println("ReadyListLo\n");
968 for (NodeConnector nodeConnector : readyListLo) {
969 if (nodeConnector == null) {
972 ci.println(nodeConnector);
976 public void _pwl(CommandInterpreter ci) {
977 ci.println("WaitingList\n");
978 for (NodeConnector nodeConnector : waitingList) {
979 if (nodeConnector == null) {
982 ci.println(nodeConnector);
986 public void _ppl(CommandInterpreter ci) {
987 ci.println("PendingList\n");
988 for (NodeConnector nodeConnector : pendingMap.keySet()) {
989 if (nodeConnector == null) {
992 ci.println(nodeConnector);
996 public void _ptick(CommandInterpreter ci) {
997 ci.println("Current timer is " + discoveryTimerTick + " msec per tick");
1000 public void _pcc(CommandInterpreter ci) {
1001 if (discoveryConsistencyCheckEnabled) {
1002 ci.println("ConsistencyChecker is currently enabled");
1004 ci.println("ConsistencyChecker is currently disabled");
1006 ci.println("Interval " + getDiscoveryConsistencyCheckInterval());
1007 ci.println("Multiple " + discoveryConsistencyCheckMultiple);
1008 ci.println("Number of times called "
1009 + discoveryConsistencyCheckCallingTimes);
1010 ci.println("Corrected count " + discoveryConsistencyCheckCorrected);
1013 public void _ptm(CommandInterpreter ci) {
1014 ci.println("Final timeout ticks " + getDiscoveryFinalTimeoutInterval());
1015 ci.println("Per timeout ticks " + discoveryTimeoutTicks);
1016 ci.println("Number of retries after initial timeout " + discoveryRetry);
1019 public void _psize(CommandInterpreter ci) {
1020 ci.println("readyListLo size " + readyListLo.size() + "\n"
1021 + "readyListHi size " + readyListHi.size() + "\n"
1022 + "waitingList size " + waitingList.size() + "\n"
1023 + "pendingMap size " + pendingMap.size() + "\n"
1024 + "edgeMap size " + edgeMap.size() + "\n" + "prodMap size "
1025 + prodMap.size() + "\n" + "agingMap size " + agingMap.size());
1028 public void _page(CommandInterpreter ci) {
1029 if (this.discoveryAgingEnabled) {
1030 ci.println("Aging is enabled");
1032 ci.println("Aging is disabled");
1034 ci.println("Current aging time limit " + this.discoveryAgeoutTicks);
1036 ci.println(" Edge Aging ");
1037 Collection<Edge> prodSet = prodMap.values();
1038 if (prodSet == null) {
1041 for (Edge edge : prodSet) {
1042 Integer aging = agingMap.get(edge.getHeadNodeConnector());
1043 if (aging != null) {
1044 ci.println(edge + " " + aging);
1048 ci.println(" NodeConnector Edge ");
1049 Set<NodeConnector> keySet = prodMap.keySet();
1050 if (keySet == null) {
1053 for (NodeConnector nc : keySet) {
1054 ci.println(nc + " " + prodMap.get(nc));
1059 public void _sage(CommandInterpreter ci) {
1060 String val = ci.nextArgument();
1062 ci.println("Please enter aging time limit. Current value "
1063 + this.discoveryAgeoutTicks);
1067 this.discoveryAgeoutTicks = Integer.parseInt(val);
1068 } catch (Exception e) {
1069 ci.println("Please enter a valid number");
1074 public void _eage(CommandInterpreter ci) {
1075 this.discoveryAgingEnabled = true;
1076 ci.println("Aging is enabled");
1080 public void _dage(CommandInterpreter ci) {
1081 this.discoveryAgingEnabled = false;
1082 ci.println("Aging is disabled");
1086 public void _scc(CommandInterpreter ci) {
1087 String val = ci.nextArgument();
1089 ci.println("Please enter CC multiple. Current multiple "
1090 + discoveryConsistencyCheckMultiple + " (interval "
1091 + getDiscoveryConsistencyCheckInterval()
1092 + ") calling times "
1093 + discoveryConsistencyCheckCallingTimes);
1097 discoveryConsistencyCheckMultiple = Integer.parseInt(val);
1098 } catch (Exception e) {
1099 ci.println("Please enter a valid number");
1104 public void _ecc(CommandInterpreter ci) {
1105 this.discoveryConsistencyCheckEnabled = true;
1106 ci.println("ConsistencyChecker is enabled");
1110 public void _dcc(CommandInterpreter ci) {
1111 this.discoveryConsistencyCheckEnabled = false;
1112 ci.println("ConsistencyChecker is disabled");
1116 public void _psnp(CommandInterpreter ci) {
1117 if (this.discoverySnoopingEnabled) {
1118 ci.println("Discovery snooping is globally enabled");
1120 ci.println("Discovery snooping is globally disabled");
1123 ci.println("\nDiscovery snooping is locally disabled on these ports");
1124 for (NodeConnector nodeConnector : discoverySnoopingDisableList) {
1125 ci.println(nodeConnector);
1130 public void _esnp(CommandInterpreter ci) {
1131 String val = ci.nextArgument();
1134 ci.println("Usage: esnp <all|nodeConnector>");
1135 } else if (val.equalsIgnoreCase("all")) {
1136 this.discoverySnoopingEnabled = true;
1137 ci.println("Discovery snooping is globally enabled");
1139 NodeConnector nodeConnector = NodeConnector.fromString(val);
1140 if (nodeConnector != null) {
1141 discoverySnoopingDisableList.remove(nodeConnector);
1142 ci.println("Discovery snooping is locally enabled on port "
1145 ci.println("Entered invalid NodeConnector " + val);
1151 public void _dsnp(CommandInterpreter ci) {
1152 String val = ci.nextArgument();
1155 ci.println("Usage: dsnp <all|nodeConnector>");
1156 } else if (val.equalsIgnoreCase("all")) {
1157 this.discoverySnoopingEnabled = false;
1158 ci.println("Discovery snooping is globally disabled");
1160 NodeConnector nodeConnector = NodeConnector.fromString(val);
1161 if (nodeConnector != null) {
1162 discoverySnoopingDisableList.add(nodeConnector);
1163 ci.println("Discovery snooping is locally disabled on port "
1166 ci.println("Entered invalid NodeConnector " + val);
1172 public void _spause(CommandInterpreter ci) {
1173 String val = ci.nextArgument();
1174 String out = "Please enter pause period less than "
1175 + discoveryBatchRestartTicks + ". Current pause period is "
1176 + discoveryBatchPausePeriod + " pause tick is "
1177 + discoveryBatchPauseTicks + ".";
1181 int pause = Integer.parseInt(val);
1182 if (pause < discoveryBatchRestartTicks) {
1183 discoveryBatchPausePeriod = pause;
1184 discoveryBatchPauseTicks = discoveryBatchRestartTicks
1185 - discoveryBatchPausePeriod;
1188 } catch (Exception e) {
1195 public void _sdi(CommandInterpreter ci) {
1196 String val = ci.nextArgument();
1197 String out = "Please enter discovery interval greater than "
1198 + discoveryBatchPausePeriod + ". Current value is "
1199 + discoveryBatchRestartTicks + ".";
1203 int restart = Integer.parseInt(val);
1204 if (restart > discoveryBatchPausePeriod) {
1205 discoveryBatchRestartTicks = restart;
1206 discoveryBatchPauseTicks = discoveryBatchRestartTicks
1207 - discoveryBatchPausePeriod;
1210 } catch (Exception e) {
1216 public void _sports(CommandInterpreter ci) {
1217 String val = ci.nextArgument();
1219 ci.println("Please enter max ports per batch. Current value is "
1220 + discoveryBatchMaxPorts);
1224 discoveryBatchMaxPorts = Integer.parseInt(val);
1225 } catch (Exception e) {
1226 ci.println("Please enter a valid number");
1231 public void _sretry(CommandInterpreter ci) {
1232 String val = ci.nextArgument();
1234 ci.println("Please enter number of retries. Current value is "
1239 discoveryRetry = Integer.parseInt(val);
1240 } catch (Exception e) {
1241 ci.println("Please enter a valid number");
1246 public void _stm(CommandInterpreter ci) {
1247 String val = ci.nextArgument();
1248 String out = "Please enter timeout tick value less than "
1249 + discoveryBatchRestartTicks + ". Current value is "
1250 + discoveryTimeoutTicks;
1253 int timeout = Integer.parseInt(val);
1254 if (timeout < discoveryBatchRestartTicks) {
1255 discoveryTimeoutTicks = timeout;
1258 } catch (Exception e) {
1265 public void _addsw(CommandInterpreter ci) {
1266 String val = ci.nextArgument();
1269 sid = Long.parseLong(val);
1270 Node node = NodeCreator.createOFNode(sid);
1272 } catch (Exception e) {
1273 ci.println("Please enter a valid number");
1278 public void _remsw(CommandInterpreter ci) {
1279 String val = ci.nextArgument();
1282 sid = Long.parseLong(val);
1283 Node node = NodeCreator.createOFNode(sid);
1284 removeDiscovery(node);
1285 } catch (Exception e) {
1286 ci.println("Please enter a valid number");
1291 public void _pthrot(CommandInterpreter ci) {
1292 if (this.throttling) {
1293 ci.println("Throttling is enabled");
1295 ci.println("Throttling is disabled");
1299 public void _ethrot(CommandInterpreter ci) {
1300 this.throttling = true;
1301 ci.println("Throttling is enabled");
1305 public void _dthrot(CommandInterpreter ci) {
1306 this.throttling = false;
1307 ci.println("Throttling is disabled");
1312 public void updateNode(Node node, UpdateType type, Set<Property> props) {
1315 addNode(node, props);
1326 public void updateNodeConnector(NodeConnector nodeConnector,
1327 UpdateType type, Set<Property> props) {
1328 Config config = null;
1330 boolean enabled = false;
1332 for (Property prop : props) {
1333 if (prop.getName().equals(Config.ConfigPropName)) {
1334 config = (Config) prop;
1335 } else if (prop.getName().equals(State.StatePropName)) {
1336 state = (State) prop;
1339 enabled = ((config != null) && (config.getValue() == Config.ADMIN_UP)
1340 && (state != null) && (state.getValue() == State.EDGE_UP));
1345 addDiscovery(nodeConnector);
1346 logger.trace("ADDED enabled {}", nodeConnector);
1348 logger.trace("ADDED disabled {}", nodeConnector);
1353 addDiscovery(nodeConnector);
1354 logger.trace("CHANGED enabled {}", nodeConnector);
1356 removeDiscovery(nodeConnector);
1357 logger.trace("CHANGED disabled {}", nodeConnector);
1361 removeDiscovery(nodeConnector);
1362 logger.trace("REMOVED enabled {}", nodeConnector);
1369 public void addNode(Node node, Set<Property> props) {
1376 public void removeNode(Node node) {
1380 removeDiscovery(node);
1383 public void updateNode(Node node, Set<Property> props) {
1386 void setController(IController s) {
1387 this.controller = s;
1390 void unsetController(IController s) {
1391 if (this.controller == s) {
1392 this.controller = null;
1396 public void setPluginInInventoryService(IPluginInInventoryService service) {
1397 this.pluginInInventoryService = service;
1400 public void unsetPluginInInventoryService(IPluginInInventoryService service) {
1401 this.pluginInInventoryService = null;
1404 public void setIDataPacketMux(IDataPacketMux service) {
1405 this.iDataPacketMux = service;
1408 public void unsetIDataPacketMux(IDataPacketMux service) {
1409 if (this.iDataPacketMux == service) {
1410 this.iDataPacketMux = null;
1414 void setDiscoveryService(IDiscoveryService s) {
1415 this.discoveryService = s;
1418 void unsetDiscoveryService(IDiscoveryService s) {
1419 if (this.discoveryService == s) {
1420 this.discoveryService = null;
1424 private void initDiscoveryPacket() {
1425 // Create LLDP ChassisID TLV
1426 chassisIdTlv = new LLDPTLV();
1427 chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue());
1429 // Create LLDP PortID TLV
1430 portIdTlv = new LLDPTLV();
1431 portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue());
1433 // Create LLDP TTL TLV
1434 byte[] ttl = new byte[] { (byte) 0, (byte) 120 };
1435 ttlTlv = new LLDPTLV();
1436 ttlTlv.setType((byte) LLDPTLV.TLVType.TTL.getValue())
1437 .setLength((short) ttl.length).setValue(ttl);
1439 customTlv = new LLDPTLV();
1443 * Function called by the dependency manager when all the required
1444 * dependencies are satisfied
1448 logger.trace("Init called");
1450 transmitQ = new LinkedBlockingQueue<NodeConnector>();
1452 readyListHi = new CopyOnWriteArrayList<NodeConnector>();
1453 readyListLo = new CopyOnWriteArrayList<NodeConnector>();
1454 waitingList = new CopyOnWriteArrayList<NodeConnector>();
1455 pendingMap = new ConcurrentHashMap<NodeConnector, Integer>();
1456 edgeMap = new ConcurrentHashMap<NodeConnector, Edge>();
1457 agingMap = new ConcurrentHashMap<NodeConnector, Integer>();
1458 prodMap = new ConcurrentHashMap<NodeConnector, Edge>();
1459 discoverySnoopingDisableList = new CopyOnWriteArrayList<NodeConnector>();
1461 discoveryTimer = new Timer("DiscoveryService");
1462 discoveryTimerTask = new DiscoveryTimerTask();
1464 transmitThread = new Thread(new DiscoveryTransmit(transmitQ));
1466 initDiscoveryPacket();
1468 registerWithOSGIConsole();
1472 * Function called by the dependency manager when at least one dependency
1473 * become unsatisfied or when the component is shutting down because for
1474 * example bundle is being stopped.
1486 discoveryTimer = null;
1487 discoveryTimerTask = null;
1488 transmitThread = null;
1492 * Function called by dependency manager after "init ()" is called and after
1493 * the services provided by the class are registered in the service registry
1497 discoveryTimer.schedule(discoveryTimerTask, discoveryTimerTick,
1498 discoveryTimerTick);
1499 transmitThread.start();
1503 * Function called after registering the service in OSGi service registry.
1506 /* get a snapshot of all the existing switches */
1511 * Function called by the dependency manager before the services exported by
1512 * the component are unregistered, this will be followed by a "destroy ()"
1517 shuttingDown = true;
1518 discoveryTimer.cancel();
1519 transmitThread.interrupt();
1523 public void tagUpdated(String containerName, Node n, short oldTag,
1524 short newTag, UpdateType t) {
1528 public void containerFlowUpdated(String containerName,
1529 ContainerFlow previousFlow, ContainerFlow currentFlow, UpdateType t) {
1533 public void nodeConnectorUpdated(String containerName, NodeConnector p,
1537 moreToReadyListHi(p);
1545 public void containerModeUpdated(UpdateType t) {
1549 private byte[] getSouceMACFromNodeID(String nodeId) {
1550 byte[] cid = HexEncode.bytesFromHexString(nodeId);
1551 byte[] sourceMac = new byte[6];
1552 int pos = cid.length - sourceMac.length;
1555 System.arraycopy(cid, pos, sourceMac, 0, sourceMac.length);
1562 * This method returns the interval which determines how often the discovery
1563 * packets will be sent. Default is 300 seconds.
1565 * @return The discovery interval in second
1567 private int getDiscoveryInterval() {
1568 String elapsedTime = System.getProperty("of.discoveryInterval");
1572 if (elapsedTime != null) {
1573 rv = Integer.parseInt(elapsedTime);
1575 } catch (Exception e) {
1582 * This method returns the timeout value in waiting for response of a
1583 * discovery query. Default is 60 seconds.
1585 * @return The discovery timeout in second
1587 private int getDiscoveryTimeout() {
1588 String elapsedTime = System.getProperty("of.discoveryTimeout");
1592 if (elapsedTime != null) {
1593 rv = Integer.parseInt(elapsedTime);
1595 } catch (Exception e) {
1602 * This method returns the number of retries after the initial discovery
1603 * packet is not received within the timeout period. Default is 2 times.
1605 * @return The number of discovery retries
1607 private int getDiscoveryRetry() {
1608 String retry = System.getProperty("of.discoveryRetry");
1611 if (retry != null) {
1613 rv = Integer.parseInt(retry);
1614 } catch (Exception e) {