opendaylight/protocol_plugins/openflow/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/DiscoveryService.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.controller.protocol_plugin.openflow.internal;
  10
  11 import java.nio.charset.Charset;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Collections;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19 import java.util.Timer;
  20 import java.util.TimerTask;
  21 import java.util.concurrent.BlockingQueue;
  22 import java.util.concurrent.ConcurrentHashMap;
  23 import java.util.concurrent.ConcurrentMap;
  24 import java.util.concurrent.CopyOnWriteArrayList;
  25 import java.util.concurrent.LinkedBlockingQueue;
  26
  27 import org.eclipse.osgi.framework.console.CommandInterpreter;
  28 import org.eclipse.osgi.framework.console.CommandProvider;
  29 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketListen;
  30 import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketMux;
  31 import org.opendaylight.controller.protocol_plugin.openflow.IDiscoveryListener;
  32 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryProvider;
  33 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimExternalListener;
  34 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
  35 import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
  36 import org.openflow.protocol.OFPhysicalPort;
  37 import org.osgi.framework.BundleContext;
  38 import org.osgi.framework.FrameworkUtil;
  39 import org.slf4j.Logger;
  40 import org.slf4j.LoggerFactory;
  41
  42 import org.opendaylight.controller.sal.core.Config;
  43 import org.opendaylight.controller.sal.core.ConstructionException;
  44 import org.opendaylight.controller.sal.core.Edge;
  45 import org.opendaylight.controller.sal.core.ContainerFlow;
  46 import org.opendaylight.controller.sal.core.IContainerListener;
  47 import org.opendaylight.controller.sal.core.Node;
  48 import org.opendaylight.controller.sal.core.NodeConnector;
  49 import org.opendaylight.controller.sal.core.Property;
  50 import org.opendaylight.controller.sal.core.State;
  51 import org.opendaylight.controller.sal.core.UpdateType;
  52 import org.opendaylight.controller.sal.packet.Ethernet;
  53 import org.opendaylight.controller.sal.packet.LLDP;
  54 import org.opendaylight.controller.sal.packet.LLDPTLV;
  55 import org.opendaylight.controller.sal.packet.LinkEncap;
  56 import org.opendaylight.controller.sal.packet.PacketResult;
  57 import org.opendaylight.controller.sal.packet.RawPacket;
  58 import org.opendaylight.controller.sal.utils.EtherTypes;
  59 import org.opendaylight.controller.sal.utils.HexEncode;
  60 import org.opendaylight.controller.sal.utils.NetUtils;
  61 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  62 import org.opendaylight.controller.sal.utils.NodeCreator;
  63
  64 /**
  65  * The class describes neighbor discovery service for an OpenFlow network.
  66  */
  67 public class DiscoveryService implements IInventoryShimExternalListener, IDataPacketListen, IContainerListener,
  68         CommandProvider {
  69     private static Logger logger = LoggerFactory.getLogger(DiscoveryService.class);
  70     private IController controller = null;
  71     private IDiscoveryListener discoveryListener = null;
  72     private IInventoryProvider inventoryProvider = null;
  73     private IDataPacketMux iDataPacketMux = null;
  74     // High priority list containing newly added ports which will be served first
  75     private List<NodeConnector> readyListHi = null;
  76     // List containing all the ports which will be served periodically
  77     private List<NodeConnector> readyListLo = null;
  78     // Staging area during quiet period
  79     private List<NodeConnector> stagingList = null;
  80     // Wait for next discovery packet. The map contains the time elapsed since
  81     // the last received LLDP frame on each node connector
  82     private ConcurrentMap<NodeConnector, Integer> holdTime = null;
  83     // Allow one more retry for newly added ports. This map contains the time
  84     // period elapsed since last discovery pkt transmission on the port.
  85     private ConcurrentMap<NodeConnector, Integer> elapsedTime = null;
  86     // OpenFlow edges keyed by head connector
  87     private ConcurrentMap<NodeConnector, Edge> edgeMap = null;
  88     // The map contains aging entry keyed by head connector of Production edge
  89     private ConcurrentMap<NodeConnector, Integer> agingMap = null;
  90     // Production edges keyed by head connector
  91     private ConcurrentMap<NodeConnector, Edge> prodMap = null;
  92
  93     private Timer discoveryTimer;
  94     private DiscoveryTimerTask discoveryTimerTask;
  95     private final static long discoveryTimerTick = 2L * 1000; // per tick in msec
  96     private int discoveryTimerTickCount = 0; // main tick counter
  97     // Max # of ports handled in one batch
  98     private int discoveryBatchMaxPorts;
  99     // Periodically restart batching process
 100     private int discoveryBatchRestartTicks;
 101     private int discoveryBatchPausePeriod = 2;
 102     // Pause after this point
 103     private int discoveryBatchPauseTicks;
 104     private int discoveryTimeoutTicks;
 105     private int discoveryThresholdTicks;
 106     private int discoveryAgeoutTicks;
 107     // multiple of discoveryBatchRestartTicks
 108     private int discoveryConsistencyCheckMultiple = 2;
 109     // CC tick counter
 110     private int discoveryConsistencyCheckTickCount;
 111     // # of times CC gets called
 112     private int discoveryConsistencyCheckCallingTimes = 0;
 113     // # of cases CC corrected
 114     private int discoveryConsistencyCheckCorrected = 0;
 115     // Enable or disable CC
 116     private boolean discoveryConsistencyCheckEnabled = true;
 117     // Enable or disable aging
 118     private boolean discoveryAgingEnabled = true;
 119     // Global flag to enable or disable LLDP snooping
 120     private boolean discoverySnoopingEnabled = true;
 121     // The list of ports that will not do LLDP snooping
 122     private List<NodeConnector> discoverySnoopingDisableList;
 123     private BlockingQueue<NodeConnector> transmitQ;
 124     private Thread transmitThread;
 125     private Boolean throttling = false; // if true, no more batching.
 126     private volatile Boolean shuttingDown = false;
 127
 128     private LLDPTLV chassisIdTlv, portIdTlv, ttlTlv, customTlv;
 129
 130     class DiscoveryTransmit implements Runnable {
 131         private final BlockingQueue<NodeConnector> transmitQ;
 132
 133         DiscoveryTransmit(BlockingQueue<NodeConnector> transmitQ) {
 134             this.transmitQ = transmitQ;
 135         }
 136
 137         @Override
 138         public void run() {
 139             while (true) {
 140                 try {
 141                     NodeConnector nodeConnector = transmitQ.take();
 142                     RawPacket outPkt = createDiscoveryPacket(nodeConnector);
 143                     sendDiscoveryPacket(nodeConnector, outPkt);
 144                     nodeConnector = null;
 145                 } catch (InterruptedException e1) {
 146                     logger.warn("DiscoveryTransmit interupted", e1.getMessage());
 147                     if (shuttingDown) {
 148                         return;
 149                     }
 150                 } catch (Exception e2) {
 151                     logger.error("", e2);
 152                 }
 153             }
 154         }
 155     }
 156
 157     class DiscoveryTimerTask extends TimerTask {
 158         @Override
 159         public void run() {
 160             checkTimeout();
 161             checkAging();
 162             doConsistencyCheck();
 163             doDiscovery();
 164         }
 165     }
 166
 167     public enum DiscoveryPeriod {
 168         INTERVAL        (300),
 169         AGEOUT          (120),
 170         THRESHOLD       (10);
 171
 172         private int time;   // sec
 173         private int tick;   // tick
 174
 175         DiscoveryPeriod(int time) {
 176             this.time = time;
 177             this.tick = time2Tick(time);
 178         }
 179
 180         public int getTime() {
 181             return time;
 182         }
 183
 184         public void setTime(int time) {
 185             this.time = time;
 186             this.tick = time2Tick(time);
 187         }
 188
 189         public int getTick() {
 190             return tick;
 191         }
 192
 193         public void setTick(int tick) {
 194             this.time = tick2Time(tick);
 195             this.tick = tick;
 196         }
 197
 198         private int time2Tick(int time) {
 199             return (int) (time / (discoveryTimerTick / 1000));
 200         }
 201
 202         private int tick2Time(int tick) {
 203             return (int) (tick * (discoveryTimerTick / 1000));
 204         }
 205     }
 206
 207     private RawPacket createDiscoveryPacket(NodeConnector nodeConnector) {
 208         String nodeId = HexEncode.longToHexString((Long) nodeConnector.getNode().getID());
 209
 210         // Create LLDP ChassisID TLV
 211         byte[] cidValue = LLDPTLV.createChassisIDTLVValue(nodeId);
 212         chassisIdTlv.setType(LLDPTLV.TLVType.ChassisID.getValue()).setLength((short) cidValue.length)
 213                 .setValue(cidValue);
 214
 215         // Create LLDP PortID TLV
 216         String portId = nodeConnector.getNodeConnectorIDString();
 217         byte[] pidValue = LLDPTLV.createPortIDTLVValue(portId);
 218         portIdTlv.setType(LLDPTLV.TLVType.PortID.getValue()).setLength((short) pidValue.length).setValue(pidValue);
 219
 220         // Create LLDP Custom TLV
 221         byte[] customValue = LLDPTLV.createCustomTLVValue(nodeConnector.toString());
 222         customTlv.setType(LLDPTLV.TLVType.Custom.getValue()).setLength((short) customValue.length)
 223                 .setValue(customValue);
 224
 225         // Create LLDP Custom Option list
 226         List<LLDPTLV> customList = new ArrayList<LLDPTLV>();
 227         customList.add(customTlv);
 228
 229         // Create discovery pkt
 230         LLDP discoveryPkt = new LLDP();
 231         discoveryPkt.setChassisId(chassisIdTlv).setPortId(portIdTlv).setTtl(ttlTlv).setOptionalTLVList(customList);
 232
 233         RawPacket rawPkt = null;
 234         try {
 235             // Create ethernet pkt
 236             byte[] sourceMac = getSourceMACFromNodeID(nodeId);
 237             Ethernet ethPkt = new Ethernet();
 238             ethPkt.setSourceMACAddress(sourceMac).setDestinationMACAddress(LLDP.LLDPMulticastMac)
 239                     .setEtherType(EtherTypes.LLDP.shortValue()).setPayload(discoveryPkt);
 240
 241             byte[] data = ethPkt.serialize();
 242             rawPkt = new RawPacket(data);
 243             rawPkt.setOutgoingNodeConnector(nodeConnector);
 244         } catch (ConstructionException cex) {
 245             logger.warn("RawPacket creation caught exception {}", cex.getMessage());
 246         } catch (Exception e) {
 247             logger.error("Failed to serialize the LLDP packet: " + e);
 248         }
 249
 250         return rawPkt;
 251     }
 252
 253     private void sendDiscoveryPacket(NodeConnector nodeConnector, RawPacket outPkt) {
 254         if (nodeConnector == null) {
 255             logger.debug("Can not send discovery packet out since nodeConnector is null");
 256             return;
 257         }
 258
 259         if (outPkt == null) {
 260             logger.debug("Can not send discovery packet out since outPkt is null");
 261             return;
 262         }
 263
 264         long sid = (Long) nodeConnector.getNode().getID();
 265         ISwitch sw = controller.getSwitches().get(sid);
 266
 267         if (sw == null) {
 268             logger.debug("Can not send discovery packet out since switch {} is null", sid);
 269             return;
 270         }
 271
 272         if (!sw.isOperational()) {
 273             logger.debug("Can not send discovery packet out since switch {} is not operational", sw);
 274             return;
 275         }
 276
 277         if (this.iDataPacketMux == null) {
 278             logger.debug("Can not send discovery packet out since DataPacket service is not available");
 279             return;
 280         }
 281
 282         logger.trace("Sending topology discovery pkt thru {}", nodeConnector);
 283         this.iDataPacketMux.transmitDataPacket(outPkt);
 284     }
 285
 286     @Override
 287     public PacketResult receiveDataPacket(RawPacket inPkt) {
 288         if (inPkt == null) {
 289             logger.debug("Ignoring null packet");
 290             return PacketResult.IGNORED;
 291         }
 292
 293         byte[] data = inPkt.getPacketData();
 294         if (data.length <= 0) {
 295             logger.trace("Ignoring zero length packet");
 296             return PacketResult.IGNORED;
 297         }
 298
 299         if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) {
 300             logger.trace("Ignoring non ethernet packet");
 301             return PacketResult.IGNORED;
 302         }
 303
 304         if (((Short) inPkt.getIncomingNodeConnector().getID()).equals(NodeConnector.SPECIALNODECONNECTORID)) {
 305             logger.trace("Ignoring ethernet packet received on special port: "
 306                     + inPkt.getIncomingNodeConnector().toString());
 307             return PacketResult.IGNORED;
 308         }
 309
 310         Ethernet ethPkt = new Ethernet();
 311         try {
 312             ethPkt.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte);
 313         } catch (Exception e) {
 314             logger.warn("Failed to decode LLDP packet from {}: {}", inPkt.getIncomingNodeConnector(), e);
 315             return PacketResult.IGNORED;
 316         }
 317
 318         if (ethPkt.getPayload() instanceof LLDP) {
 319             NodeConnector dst = inPkt.getIncomingNodeConnector();
 320             if (isEnabled(dst)) {
 321                 if (!processDiscoveryPacket(dst, ethPkt)) {
 322                     // Snoop the discovery pkt if not generated from us
 323                     snoopDiscoveryPacket(dst, ethPkt);
 324                 }
 325                 return PacketResult.CONSUME;
 326             }
 327         }
 328         return PacketResult.IGNORED;
 329     }
 330
 331     /*
 332      * Snoop incoming discovery frames generated by the production network
 333      * neighbor switch
 334      */
 335     private void snoopDiscoveryPacket(NodeConnector dstNodeConnector, Ethernet ethPkt) {
 336         if (!this.discoverySnoopingEnabled || discoverySnoopingDisableList.contains(dstNodeConnector)) {
 337             logger.trace("Discarded received discovery packet on {} since snooping is turned off", dstNodeConnector);
 338             return;
 339         }
 340
 341         if ((dstNodeConnector == null) || (ethPkt == null)) {
 342             logger.trace("Quit snooping discovery packet: Null node connector or packet");
 343             return;
 344         }
 345
 346         LLDP lldp = (LLDP) ethPkt.getPayload();
 347
 348         try {
 349             String nodeId = LLDPTLV.getHexStringValue(lldp.getChassisId().getValue(), lldp.getChassisId().getLength());
 350             String portId = LLDPTLV.getStringValue(lldp.getPortId().getValue(), lldp.getPortId().getLength());
 351             byte[] systemNameBytes = null;
 352             // get system name if present in the LLDP pkt
 353             for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) {
 354                 if (lldptlv.getType() == LLDPTLV.TLVType.SystemName.getValue()) {
 355                     systemNameBytes = lldptlv.getValue();
 356                     break;
 357                 }
 358             }
 359             String nodeName = (systemNameBytes == null) ? nodeId
 360                     : new String(systemNameBytes, Charset.defaultCharset());
 361             Node srcNode = new Node(Node.NodeIDType.PRODUCTION, nodeName);
 362             NodeConnector srcNodeConnector = NodeConnectorCreator.createNodeConnector(
 363                     NodeConnector.NodeConnectorIDType.PRODUCTION, portId, srcNode);
 364
 365             Edge edge = null;
 366             Set<Property> props = null;
 367             edge = new Edge(srcNodeConnector, dstNodeConnector);
 368             props = getProps(dstNodeConnector);
 369
 370             updateProdEdge(edge, props);
 371         } catch (Exception e) {
 372             logger.warn("Caught exception ", e);
 373         }
 374     }
 375
 376     /*
 377      * Handle discovery frames generated by our controller
 378      *
 379      * @return true if it's a success
 380      */
 381     private boolean processDiscoveryPacket(NodeConnector dstNodeConnector, Ethernet ethPkt) {
 382         if ((dstNodeConnector == null) || (ethPkt == null)) {
 383             logger.trace("Ignoring processing of discovery packet: Null node connector or packet");
 384             return false;
 385         }
 386
 387         logger.trace("Handle discovery packet {} from {}", ethPkt, dstNodeConnector);
 388
 389         LLDP lldp = (LLDP) ethPkt.getPayload();
 390
 391         List<LLDPTLV> optionalTLVList = lldp.getOptionalTLVList();
 392         if (optionalTLVList == null) {
 393             logger.info("The discovery packet with null custom option from {}", dstNodeConnector);
 394             return false;
 395         }
 396
 397         Node srcNode = null;
 398         NodeConnector srcNodeConnector = null;
 399         for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) {
 400             if (lldptlv.getType() == LLDPTLV.TLVType.Custom.getValue()) {
 401                 String ncString = LLDPTLV.getCustomString(lldptlv.getValue(), lldptlv.getLength());
 402                 srcNodeConnector = NodeConnector.fromString(ncString);
 403                 if (srcNodeConnector != null) {
 404                     srcNode = srcNodeConnector.getNode();
 405                 }
 406             }
 407         }
 408
 409         if ((srcNode == null) || (srcNodeConnector == null)) {
 410             logger.trace("Received non-controller generated discovery packet from {}", dstNodeConnector);
 411             return false;
 412         }
 413
 414         // push it out to Topology
 415         Edge edge = null;
 416         Set<Property> props = null;
 417         try {
 418             edge = new Edge(srcNodeConnector, dstNodeConnector);
 419             props = getProps(dstNodeConnector);
 420         } catch (ConstructionException e) {
 421             logger.error("Caught exception ", e);
 422         }
 423         addEdge(edge, props);
 424
 425         logger.trace("Received discovery packet for Edge {}", edge);
 426
 427         return true;
 428     }
 429
 430     public Map<String, Property> getPropMap(NodeConnector nodeConnector) {
 431         if (nodeConnector == null) {
 432             return null;
 433         }
 434
 435         if (inventoryProvider == null) {
 436             return null;
 437         }
 438
 439         Map<NodeConnector, Map<String, Property>> props = inventoryProvider.getNodeConnectorProps(false);
 440         if (props == null) {
 441             return null;
 442         }
 443
 444         return props.get(nodeConnector);
 445     }
 446
 447     public Property getProp(NodeConnector nodeConnector, String propName) {
 448         Map<String, Property> propMap = getPropMap(nodeConnector);
 449         if (propMap == null) {
 450             return null;
 451         }
 452
 453         Property prop = propMap.get(propName);
 454         return prop;
 455     }
 456
 457     public Set<Property> getProps(NodeConnector nodeConnector) {
 458         Map<String, Property> propMap = getPropMap(nodeConnector);
 459         if (propMap == null) {
 460             return null;
 461         }
 462
 463         Set<Property> props = new HashSet<Property>(propMap.values());
 464         return props;
 465     }
 466
 467     private boolean isEnabled(NodeConnector nodeConnector) {
 468         if (nodeConnector == null) {
 469             return false;
 470         }
 471
 472         Config config = (Config) getProp(nodeConnector, Config.ConfigPropName);
 473         State state = (State) getProp(nodeConnector, State.StatePropName);
 474         return ((config != null) && (config.getValue() == Config.ADMIN_UP) && (state != null) && (state.getValue() == State.EDGE_UP));
 475     }
 476
 477     private boolean isTracked(NodeConnector nodeConnector) {
 478         if (readyListHi.contains(nodeConnector)) {
 479             return true;
 480         }
 481
 482         if (readyListLo.contains(nodeConnector)) {
 483             return true;
 484         }
 485
 486         if (holdTime.keySet().contains(nodeConnector)) {
 487             return true;
 488         }
 489
 490         if (stagingList.contains(nodeConnector)) {
 491             return true;
 492         }
 493
 494         return false;
 495     }
 496
 497     private Set<NodeConnector> getWorkingSet() {
 498         Set<NodeConnector> workingSet = new HashSet<NodeConnector>();
 499         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 500
 501         for (NodeConnector nodeConnector : readyListHi) {
 502             if (isOverLimit(workingSet.size())) {
 503                 break;
 504             }
 505
 506             workingSet.add(nodeConnector);
 507             removeSet.add(nodeConnector);
 508
 509             // Put it in the map and start the timer. It may need retry.
 510             elapsedTime.put(nodeConnector, 0);
 511         }
 512         readyListHi.removeAll(removeSet);
 513
 514         removeSet.clear();
 515         for (NodeConnector nodeConnector : readyListLo) {
 516             if (isOverLimit(workingSet.size())) {
 517                 break;
 518             }
 519
 520             workingSet.add(nodeConnector);
 521             removeSet.add(nodeConnector);
 522         }
 523         readyListLo.removeAll(removeSet);
 524
 525         return workingSet;
 526     }
 527
 528     private Boolean isOverLimit(int size) {
 529         return ((size >= discoveryBatchMaxPorts) && !throttling);
 530     }
 531
 532     private void addDiscovery() {
 533         Map<Long, ISwitch> switches = controller.getSwitches();
 534         Set<Long> sidSet = switches.keySet();
 535         if (sidSet == null) {
 536             return;
 537         }
 538         for (Long sid : sidSet) {
 539             Node node = NodeCreator.createOFNode(sid);
 540             addDiscovery(node);
 541         }
 542     }
 543
 544     private void addDiscovery(Node node) {
 545         Map<Long, ISwitch> switches = controller.getSwitches();
 546         ISwitch sw = switches.get(node.getID());
 547         List<OFPhysicalPort> ports = sw.getEnabledPorts();
 548         if (ports == null) {
 549             return;
 550         }
 551         for (OFPhysicalPort port : ports) {
 552             NodeConnector nodeConnector = NodeConnectorCreator.createOFNodeConnector(port.getPortNumber(), node);
 553             if (!readyListHi.contains(nodeConnector)) {
 554                 readyListHi.add(nodeConnector);
 555             }
 556         }
 557     }
 558
 559     private void addDiscovery(NodeConnector nodeConnector) {
 560         if (isTracked(nodeConnector)) {
 561             return;
 562         }
 563
 564         readyListHi.add(nodeConnector);
 565     }
 566
 567     private Set<NodeConnector> getRemoveSet(Collection<NodeConnector> c, Node node) {
 568         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 569         if (c == null) {
 570             return removeSet;
 571         }
 572         for (NodeConnector nodeConnector : c) {
 573             if (node.equals(nodeConnector.getNode())) {
 574                 removeSet.add(nodeConnector);
 575             }
 576         }
 577         return removeSet;
 578     }
 579
 580     private void removeDiscovery(Node node) {
 581         Set<NodeConnector> removeSet;
 582
 583         removeSet = getRemoveSet(readyListHi, node);
 584         readyListHi.removeAll(removeSet);
 585
 586         removeSet = getRemoveSet(readyListLo, node);
 587         readyListLo.removeAll(removeSet);
 588
 589         removeSet = getRemoveSet(stagingList, node);
 590         stagingList.removeAll(removeSet);
 591
 592         removeSet = getRemoveSet(holdTime.keySet(), node);
 593         for (NodeConnector nodeConnector : removeSet) {
 594             holdTime.remove(nodeConnector);
 595         }
 596
 597         removeSet = getRemoveSet(edgeMap.keySet(), node);
 598         for (NodeConnector nodeConnector : removeSet) {
 599             removeEdge(nodeConnector, false);
 600         }
 601
 602         removeSet = getRemoveSet(prodMap.keySet(), node);
 603         for (NodeConnector nodeConnector : removeSet) {
 604             removeProdEdge(nodeConnector);
 605         }
 606     }
 607
 608     private void removeDiscovery(NodeConnector nodeConnector) {
 609         readyListHi.remove(nodeConnector);
 610         readyListLo.remove(nodeConnector);
 611         stagingList.remove(nodeConnector);
 612         holdTime.remove(nodeConnector);
 613         removeEdge(nodeConnector, false);
 614         removeProdEdge(nodeConnector);
 615     }
 616
 617     private void checkTimeout() {
 618         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 619         int ticks;
 620
 621         Set<NodeConnector> monitorSet = holdTime.keySet();
 622         if (monitorSet != null) {
 623             for (NodeConnector nodeConnector : monitorSet) {
 624                 ticks = holdTime.get(nodeConnector);
 625                 holdTime.put(nodeConnector, ++ticks);
 626                 if (ticks >= discoveryTimeoutTicks) {
 627                     // timeout the edge
 628                     removeSet.add(nodeConnector);
 629                     logger.trace("Discovery timeout {}", nodeConnector);
 630                 }
 631             }
 632         }
 633
 634         for (NodeConnector nodeConnector : removeSet) {
 635             removeEdge(nodeConnector);
 636         }
 637
 638         Set<NodeConnector> retrySet = new HashSet<NodeConnector>();
 639         Set<NodeConnector> ncSet = elapsedTime.keySet();
 640         if ((ncSet != null) && (ncSet.size() > 0)) {
 641             for (NodeConnector nodeConnector : ncSet) {
 642                 ticks = elapsedTime.get(nodeConnector);
 643                 elapsedTime.put(nodeConnector, ++ticks);
 644                 if (ticks >= discoveryThresholdTicks) {
 645                     retrySet.add(nodeConnector);
 646                 }
 647             }
 648
 649             for (NodeConnector nodeConnector : retrySet) {
 650                 // Allow one more retry
 651                 readyListLo.add(nodeConnector);
 652                 elapsedTime.remove(nodeConnector);
 653             }
 654         }
 655     }
 656
 657     private void checkAging() {
 658         if (!discoveryAgingEnabled) {
 659             return;
 660         }
 661
 662         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 663         int ticks;
 664
 665         Set<NodeConnector> agingSet = agingMap.keySet();
 666         if (agingSet != null) {
 667             for (NodeConnector nodeConnector : agingSet) {
 668                 ticks = agingMap.get(nodeConnector);
 669                 agingMap.put(nodeConnector, ++ticks);
 670                 if (ticks > discoveryAgeoutTicks) {
 671                     // age out the edge
 672                     removeSet.add(nodeConnector);
 673                     logger.trace("Discovery age out {}", nodeConnector);
 674                 }
 675             }
 676         }
 677
 678         for (NodeConnector nodeConnector : removeSet) {
 679             removeProdEdge(nodeConnector);
 680         }
 681     }
 682
 683     private void doDiscovery() {
 684         if (++discoveryTimerTickCount <= discoveryBatchPauseTicks) {
 685             for (NodeConnector nodeConnector : getWorkingSet()) {
 686                 transmitQ.add(nodeConnector);
 687                 // Move to staging area after it's served
 688                 if (!stagingList.contains(nodeConnector)) {
 689                     stagingList.add(nodeConnector);
 690                 }
 691             }
 692         } else if (discoveryTimerTickCount >= discoveryBatchRestartTicks) {
 693             discoveryTimerTickCount = 0;
 694             for (NodeConnector nodeConnector : stagingList) {
 695                 if (!readyListLo.contains(nodeConnector)) {
 696                     readyListLo.add(nodeConnector);
 697                 }
 698             }
 699             stagingList.removeAll(readyListLo);
 700         }
 701     }
 702
 703     private void doConsistencyCheck() {
 704         if (!discoveryConsistencyCheckEnabled) {
 705             return;
 706         }
 707
 708         if (++discoveryConsistencyCheckTickCount % getDiscoveryConsistencyCheckInterval() != 0) {
 709             return;
 710         }
 711
 712         discoveryConsistencyCheckCallingTimes++;
 713
 714         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 715         Set<NodeConnector> ncSet = edgeMap.keySet();
 716         if (ncSet == null) {
 717             return;
 718         }
 719         for (NodeConnector nodeConnector : ncSet) {
 720             if (!isEnabled(nodeConnector)) {
 721                 removeSet.add(nodeConnector);
 722                 discoveryConsistencyCheckCorrected++;
 723                 logger.debug("ConsistencyChecker: remove disabled {}", nodeConnector);
 724                 continue;
 725             }
 726
 727             if (!isTracked(nodeConnector)) {
 728                 stagingList.add(nodeConnector);
 729                 discoveryConsistencyCheckCorrected++;
 730                 logger.debug("ConsistencyChecker: add back untracked {}", nodeConnector);
 731                 continue;
 732             }
 733         }
 734
 735         for (NodeConnector nodeConnector : removeSet) {
 736             removeEdge(nodeConnector, false);
 737         }
 738
 739         // remove stale entries
 740         removeSet.clear();
 741         for (NodeConnector nodeConnector : stagingList) {
 742             if (!isEnabled(nodeConnector)) {
 743                 removeSet.add(nodeConnector);
 744                 discoveryConsistencyCheckCorrected++;
 745                 logger.debug("ConsistencyChecker: remove disabled {}", nodeConnector);
 746             }
 747         }
 748         stagingList.removeAll(removeSet);
 749
 750         // Get a snapshot of all the existing switches
 751         Map<Long, ISwitch> switches = this.controller.getSwitches();
 752         for (ISwitch sw : switches.values()) {
 753             for (OFPhysicalPort port : sw.getEnabledPorts()) {
 754                 Node node = NodeCreator.createOFNode(sw.getId());
 755                 NodeConnector nodeConnector = NodeConnectorCreator.createOFNodeConnector(port.getPortNumber(), node);
 756                 if (!isTracked(nodeConnector)) {
 757                     stagingList.add(nodeConnector);
 758                     discoveryConsistencyCheckCorrected++;
 759                     logger.debug("ConsistencyChecker: add back untracked {}", nodeConnector);
 760                 }
 761             }
 762         }
 763     }
 764
 765     private void addEdge(Edge edge, Set<Property> props) {
 766         if (edge == null) {
 767             return;
 768         }
 769
 770         NodeConnector src = edge.getTailNodeConnector();
 771         NodeConnector dst = edge.getHeadNodeConnector();
 772         if (!src.getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
 773             holdTime.put(dst, 0);
 774         } else {
 775             agingMap.put(dst, 0);
 776         }
 777         elapsedTime.remove(src);
 778
 779         // notify
 780         updateEdge(edge, UpdateType.ADDED, props);
 781         logger.trace("Add edge {}", edge);
 782     }
 783
 784     /**
 785      * Update Production Edge
 786      *
 787      * @param edge
 788      *            The Production Edge
 789      * @param props
 790      *            Properties associated with the edge
 791      */
 792     private void updateProdEdge(Edge edge, Set<Property> props) {
 793         NodeConnector edgePort = edge.getHeadNodeConnector();
 794
 795         /* Do not update in case there is an existing OpenFlow link */
 796         if (edgeMap.get(edgePort) != null) {
 797             logger.trace("Discarded edge {} since there is an existing OF link {}", edge, edgeMap.get(edgePort));
 798             return;
 799         }
 800
 801         /* Look for any existing Production Edge */
 802         Edge oldEdge = prodMap.get(edgePort);
 803         if (oldEdge == null) {
 804             /* Let's add a new one */
 805             addEdge(edge, props);
 806         } else if (!edge.equals(oldEdge)) {
 807             /* Remove the old one first */
 808             removeProdEdge(oldEdge.getHeadNodeConnector());
 809             /* Then add the new one */
 810             addEdge(edge, props);
 811         } else {
 812             /* o/w, just reset the aging timer */
 813             NodeConnector dst = edge.getHeadNodeConnector();
 814             agingMap.put(dst, 0);
 815         }
 816     }
 817
 818     /**
 819      * Remove Production Edge for a given edge port
 820      *
 821      * @param edgePort
 822      *            The OF edge port
 823      */
 824     private void removeProdEdge(NodeConnector edgePort) {
 825         agingMap.remove(edgePort);
 826
 827         Edge edge = null;
 828         Set<NodeConnector> prodKeySet = prodMap.keySet();
 829         if ((prodKeySet != null) && (prodKeySet.contains(edgePort))) {
 830             edge = prodMap.get(edgePort);
 831             prodMap.remove(edgePort);
 832         }
 833
 834         // notify Topology
 835         if (this.discoveryListener != null) {
 836             this.discoveryListener.notifyEdge(edge, UpdateType.REMOVED, null);
 837         }
 838         logger.trace("Remove edge {}", edge);
 839     }
 840
 841     /*
 842      * Remove OpenFlow edge
 843      */
 844     private void removeEdge(NodeConnector nodeConnector, boolean stillEnabled) {
 845         holdTime.remove(nodeConnector);
 846         readyListLo.remove(nodeConnector);
 847         readyListHi.remove(nodeConnector);
 848
 849         if (stillEnabled) {
 850             // keep discovering
 851             if (!stagingList.contains(nodeConnector)) {
 852                 stagingList.add(nodeConnector);
 853             }
 854         } else {
 855             // stop it
 856             stagingList.remove(nodeConnector);
 857         }
 858
 859         Edge edge = null;
 860         Set<NodeConnector> edgeKeySet = edgeMap.keySet();
 861         if ((edgeKeySet != null) && (edgeKeySet.contains(nodeConnector))) {
 862             edge = edgeMap.get(nodeConnector);
 863             edgeMap.remove(nodeConnector);
 864         }
 865
 866         // notify Topology
 867         if (this.discoveryListener != null) {
 868             this.discoveryListener.notifyEdge(edge, UpdateType.REMOVED, null);
 869         }
 870         logger.trace("Remove {}", nodeConnector);
 871     }
 872
 873     private void removeEdge(NodeConnector nodeConnector) {
 874         removeEdge(nodeConnector, isEnabled(nodeConnector));
 875     }
 876
 877     private void updateEdge(Edge edge, UpdateType type, Set<Property> props) {
 878         if (discoveryListener == null) {
 879             return;
 880         }
 881
 882         this.discoveryListener.notifyEdge(edge, type, props);
 883
 884         NodeConnector src = edge.getTailNodeConnector(), dst = edge.getHeadNodeConnector();
 885         if (!src.getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
 886             if (type == UpdateType.ADDED) {
 887                 edgeMap.put(dst, edge);
 888             } else {
 889                 edgeMap.remove(dst);
 890             }
 891         } else {
 892             /*
 893              * Save Production edge into different DB keyed by the Edge port
 894              */
 895             if (type == UpdateType.ADDED) {
 896                 prodMap.put(dst, edge);
 897             } else {
 898                 prodMap.remove(dst);
 899             }
 900         }
 901     }
 902
 903     private void moveToReadyListHi(NodeConnector nodeConnector) {
 904         if (readyListLo.contains(nodeConnector)) {
 905             readyListLo.remove(nodeConnector);
 906         } else if (stagingList.contains(nodeConnector)) {
 907             stagingList.remove(nodeConnector);
 908         }
 909         readyListHi.add(nodeConnector);
 910     }
 911
 912     private void registerWithOSGIConsole() {
 913         BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
 914         bundleContext.registerService(CommandProvider.class.getName(), this, null);
 915     }
 916
 917     private int getDiscoveryConsistencyCheckInterval() {
 918         return discoveryConsistencyCheckMultiple * discoveryBatchRestartTicks;
 919     }
 920
 921     @Override
 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 psl                             - Print stagingList entries\n");
 928         help.append("\t pht                             - Print hold time\n");
 929         help.append("\t pet                             - Print elapsed time\n");
 930         help.append("\t ptick                           - Print tick time in msec\n");
 931         help.append("\t pcc                             - Print CC info\n");
 932         help.append("\t psize                           - Print sizes of all the lists\n");
 933         help.append("\t ptm                             - Print timeout info\n");
 934         help.append("\t ecc                             - Enable CC\n");
 935         help.append("\t dcc                             - Disable CC\n");
 936         help.append("\t scc [multiple]                  - Set/show CC multiple and interval\n");
 937         help.append("\t sports [ports]                  - Set/show max ports per batch\n");
 938         help.append("\t spause [ticks]                  - Set/show pause period\n");
 939         help.append("\t sdi [ticks]                     - Set/show discovery interval in ticks\n");
 940         help.append("\t addsw <swid>                    - Add a switch\n");
 941         help.append("\t remsw <swid>                    - Remove a switch\n");
 942         help.append("\t page                            - Print aging info\n");
 943         help.append("\t sage                            - Set/Show aging time limit\n");
 944         help.append("\t eage                            - Enable aging\n");
 945         help.append("\t dage                            - Disable aging\n");
 946         help.append("\t pthrot                          - Print throttling\n");
 947         help.append("\t ethrot                          - Enable throttling\n");
 948         help.append("\t dthrot                          - Disable throttling\n");
 949         help.append("\t psnp                            - Print LLDP snooping\n");
 950         help.append("\t esnp <all|nodeConnector>        - Enable LLDP snooping\n");
 951         help.append("\t dsnp <all|nodeConnector>        - Disable LLDP snooping\n");
 952         return help.toString();
 953     }
 954
 955     private List<NodeConnector> sortList(Collection<NodeConnector> ncs) {
 956         List<String> ncStrArray = new ArrayList<String>();
 957         for (NodeConnector nc : ncs) {
 958             ncStrArray.add(nc.toString());
 959         }
 960         Collections.sort(ncStrArray);
 961
 962         List<NodeConnector> sortedNodeConnectors = new ArrayList<NodeConnector>();
 963         for (String ncStr : ncStrArray) {
 964             sortedNodeConnectors.add(NodeConnector.fromString(ncStr));
 965         }
 966
 967         return sortedNodeConnectors;
 968     }
 969
 970     public void _prlh(CommandInterpreter ci) {
 971         ci.println("readyListHi\n");
 972         for (NodeConnector nodeConnector : sortList(readyListHi)) {
 973             if (nodeConnector == null) {
 974                 continue;
 975             }
 976             ci.println(nodeConnector);
 977         }
 978         ci.println("Total number of Node Connectors: " + readyListHi.size());
 979     }
 980
 981     public void _prll(CommandInterpreter ci) {
 982         ci.println("readyListLo\n");
 983         for (NodeConnector nodeConnector : sortList(readyListLo)) {
 984             if (nodeConnector == null) {
 985                 continue;
 986             }
 987             ci.println(nodeConnector);
 988         }
 989         ci.println("Total number of Node Connectors: " + readyListLo.size());
 990     }
 991
 992     public void _psl(CommandInterpreter ci) {
 993         ci.println("stagingList\n");
 994         for (NodeConnector nodeConnector : sortList(stagingList)) {
 995             if (nodeConnector == null) {
 996                 continue;
 997             }
 998             ci.println(nodeConnector);
 999         }
1000         ci.println("Total number of Node Connectors: " + stagingList.size());
1001     }
1002
1003     public void _pht(CommandInterpreter ci) {
1004         ci.println("          NodeConnector            Last rx LLDP (sec)");
1005         for (ConcurrentMap.Entry<NodeConnector, Integer> entry: holdTime.entrySet()) {
1006             ci.println(entry.getKey() + "\t\t" + entry.getValue() * (discoveryTimerTick / 1000));
1007         }
1008         ci.println("\nSize: " + holdTime.size() + "\tTimeout: " + discoveryTimeoutTicks * (discoveryTimerTick / 1000)
1009                 + " sec");
1010     }
1011
1012     public void _pet(CommandInterpreter ci) {
1013         ci.println("          NodeConnector            Elapsed Time (sec)");
1014         for (ConcurrentMap.Entry<NodeConnector, Integer> entry: elapsedTime.entrySet()) {
1015             ci.println(entry.getKey() + "\t\t" + entry.getValue() * (discoveryTimerTick / 1000));
1016         }
1017         ci.println("\nSize: " + elapsedTime.size() + "\tThreshold: " + DiscoveryPeriod.THRESHOLD.getTime() + " sec");
1018     }
1019
1020     public void _ptick(CommandInterpreter ci) {
1021         ci.println("Current timer is " + discoveryTimerTick + " msec per tick");
1022     }
1023
1024     public void _pcc(CommandInterpreter ci) {
1025         if (discoveryConsistencyCheckEnabled) {
1026             ci.println("ConsistencyChecker is currently enabled");
1027         } else {
1028             ci.println("ConsistencyChecker is currently disabled");
1029         }
1030         ci.println("Interval " + getDiscoveryConsistencyCheckInterval());
1031         ci.println("Multiple " + discoveryConsistencyCheckMultiple);
1032         ci.println("Number of times called " + discoveryConsistencyCheckCallingTimes);
1033         ci.println("Corrected count " + discoveryConsistencyCheckCorrected);
1034     }
1035
1036     public void _ptm(CommandInterpreter ci) {
1037         ci.println("Timeout " + discoveryTimeoutTicks + " ticks, " + discoveryTimerTick / 1000 + " sec per tick.");
1038     }
1039
1040     public void _psize(CommandInterpreter ci) {
1041         ci.println("readyListLo size " + readyListLo.size() + "\n" + "readyListHi size " + readyListHi.size() + "\n"
1042                 + "stagingList size " + stagingList.size() + "\n" + "holdTime size " + holdTime.size() + "\n"
1043                 + "edgeMap size " + edgeMap.size() + "\n" + "prodMap size " + prodMap.size() + "\n" + "agingMap size "
1044                 + agingMap.size() + "\n" + "elapsedTime size " + elapsedTime.size());
1045     }
1046
1047     public void _page(CommandInterpreter ci) {
1048         if (this.discoveryAgingEnabled) {
1049             ci.println("Aging is enabled");
1050         } else {
1051             ci.println("Aging is disabled");
1052         }
1053         ci.println("Current aging time limit " + this.discoveryAgeoutTicks);
1054         ci.println("\n");
1055         ci.println("                           Edge                                 Aging ");
1056         Collection<Edge> prodSet = prodMap.values();
1057         if (prodSet == null) {
1058             return;
1059         }
1060         for (Edge edge : prodSet) {
1061             Integer aging = agingMap.get(edge.getHeadNodeConnector());
1062             if (aging != null) {
1063                 ci.println(edge + "      " + aging);
1064             }
1065         }
1066         ci.println("\n");
1067         ci.println("              NodeConnector                                                 Edge ");
1068         Set<NodeConnector> keySet = prodMap.keySet();
1069         if (keySet == null) {
1070             return;
1071         }
1072         for (NodeConnector nc : keySet) {
1073             ci.println(nc + "      " + prodMap.get(nc));
1074         }
1075         return;
1076     }
1077
1078     public void _sage(CommandInterpreter ci) {
1079         String val = ci.nextArgument();
1080         if (val == null) {
1081             ci.println("Please enter aging time limit. Current value " + this.discoveryAgeoutTicks);
1082             return;
1083         }
1084         try {
1085             this.discoveryAgeoutTicks = Integer.parseInt(val);
1086         } catch (Exception e) {
1087             ci.println("Please enter a valid number");
1088         }
1089         return;
1090     }
1091
1092     public void _eage(CommandInterpreter ci) {
1093         this.discoveryAgingEnabled = true;
1094         ci.println("Aging is enabled");
1095         return;
1096     }
1097
1098     public void _dage(CommandInterpreter ci) {
1099         this.discoveryAgingEnabled = false;
1100         ci.println("Aging is disabled");
1101         return;
1102     }
1103
1104     public void _scc(CommandInterpreter ci) {
1105         String val = ci.nextArgument();
1106         if (val == null) {
1107             ci.println("Please enter CC multiple. Current multiple " + discoveryConsistencyCheckMultiple
1108                     + " (interval " + getDiscoveryConsistencyCheckInterval() + ") calling times "
1109                     + discoveryConsistencyCheckCallingTimes);
1110             return;
1111         }
1112         try {
1113             discoveryConsistencyCheckMultiple = Integer.parseInt(val);
1114         } catch (Exception e) {
1115             ci.println("Please enter a valid number");
1116         }
1117         return;
1118     }
1119
1120     public void _ecc(CommandInterpreter ci) {
1121         this.discoveryConsistencyCheckEnabled = true;
1122         ci.println("ConsistencyChecker is enabled");
1123         return;
1124     }
1125
1126     public void _dcc(CommandInterpreter ci) {
1127         this.discoveryConsistencyCheckEnabled = false;
1128         ci.println("ConsistencyChecker is disabled");
1129         return;
1130     }
1131
1132     public void _psnp(CommandInterpreter ci) {
1133         if (this.discoverySnoopingEnabled) {
1134             ci.println("Discovery snooping is globally enabled");
1135         } else {
1136             ci.println("Discovery snooping is globally disabled");
1137         }
1138
1139         ci.println("\nDiscovery snooping is locally disabled on these ports");
1140         for (NodeConnector nodeConnector : discoverySnoopingDisableList) {
1141             ci.println(nodeConnector);
1142         }
1143         return;
1144     }
1145
1146     public void _esnp(CommandInterpreter ci) {
1147         String val = ci.nextArgument();
1148
1149         if (val == null) {
1150             ci.println("Usage: esnp <all|nodeConnector>");
1151         } else if (val.equalsIgnoreCase("all")) {
1152             this.discoverySnoopingEnabled = true;
1153             ci.println("Discovery snooping is globally enabled");
1154         } else {
1155             NodeConnector nodeConnector = NodeConnector.fromString(val);
1156             if (nodeConnector != null) {
1157                 discoverySnoopingDisableList.remove(nodeConnector);
1158                 ci.println("Discovery snooping is locally enabled on port " + nodeConnector);
1159             } else {
1160                 ci.println("Entered invalid NodeConnector " + val);
1161             }
1162         }
1163         return;
1164     }
1165
1166     public void _dsnp(CommandInterpreter ci) {
1167         String val = ci.nextArgument();
1168
1169         if (val == null) {
1170             ci.println("Usage: dsnp <all|nodeConnector>");
1171         } else if (val.equalsIgnoreCase("all")) {
1172             this.discoverySnoopingEnabled = false;
1173             ci.println("Discovery snooping is globally disabled");
1174         } else {
1175             NodeConnector nodeConnector = NodeConnector.fromString(val);
1176             if (nodeConnector != null) {
1177                 discoverySnoopingDisableList.add(nodeConnector);
1178                 ci.println("Discovery snooping is locally disabled on port " + nodeConnector);
1179             } else {
1180                 ci.println("Entered invalid NodeConnector " + val);
1181             }
1182         }
1183         return;
1184     }
1185
1186     public void _spause(CommandInterpreter ci) {
1187         String val = ci.nextArgument();
1188         String out = "Please enter pause period less than " + discoveryBatchRestartTicks + ". Current pause period is "
1189                 + discoveryBatchPausePeriod + " ticks, pause at " + discoveryBatchPauseTicks + " ticks, "
1190                 + discoveryTimerTick / 1000 + " sec per tick.";
1191
1192         if (val != null) {
1193             try {
1194                 int pause = Integer.parseInt(val);
1195                 if (pause < discoveryBatchRestartTicks) {
1196                     discoveryBatchPausePeriod = pause;
1197                     discoveryBatchPauseTicks = getDiscoveryPauseInterval();
1198                     return;
1199                 }
1200             } catch (Exception e) {
1201             }
1202         }
1203
1204         ci.println(out);
1205     }
1206
1207     public void _sdi(CommandInterpreter ci) {
1208         String val = ci.nextArgument();
1209         String out = "Please enter discovery interval in ticks. Current value is " + discoveryBatchRestartTicks + " ticks, "
1210                 + discoveryTimerTick / 1000 + " sec per tick.";
1211
1212         if (val != null) {
1213             try {
1214                 int ticks = Integer.parseInt(val);
1215                 DiscoveryPeriod.INTERVAL.setTick(ticks);
1216                 discoveryBatchRestartTicks = getDiscoveryInterval();
1217                 discoveryBatchPauseTicks = getDiscoveryPauseInterval();
1218                 discoveryTimeoutTicks = getDiscoveryTimeout();
1219                 return;
1220             } catch (Exception e) {
1221             }
1222         }
1223         ci.println(out);
1224     }
1225
1226     public void _sports(CommandInterpreter ci) {
1227         String val = ci.nextArgument();
1228         if (val == null) {
1229             ci.println("Please enter max ports per batch. Current value is " + discoveryBatchMaxPorts);
1230             return;
1231         }
1232         try {
1233             discoveryBatchMaxPorts = Integer.parseInt(val);
1234         } catch (Exception e) {
1235             ci.println("Please enter a valid number");
1236         }
1237         return;
1238     }
1239
1240     public void _addsw(CommandInterpreter ci) {
1241         String val = ci.nextArgument();
1242         Long sid;
1243         try {
1244             sid = Long.parseLong(val);
1245             Node node = NodeCreator.createOFNode(sid);
1246             addDiscovery(node);
1247         } catch (Exception e) {
1248             ci.println("Please enter a valid number");
1249         }
1250         return;
1251     }
1252
1253     public void _remsw(CommandInterpreter ci) {
1254         String val = ci.nextArgument();
1255         Long sid;
1256         try {
1257             sid = Long.parseLong(val);
1258             Node node = NodeCreator.createOFNode(sid);
1259             removeDiscovery(node);
1260         } catch (Exception e) {
1261             ci.println("Please enter a valid number");
1262         }
1263         return;
1264     }
1265
1266     public void _pthrot(CommandInterpreter ci) {
1267         if (this.throttling) {
1268             ci.println("Throttling is enabled");
1269         } else {
1270             ci.println("Throttling is disabled");
1271         }
1272     }
1273
1274     public void _ethrot(CommandInterpreter ci) {
1275         this.throttling = true;
1276         ci.println("Throttling is enabled");
1277         return;
1278     }
1279
1280     public void _dthrot(CommandInterpreter ci) {
1281         this.throttling = false;
1282         ci.println("Throttling is disabled");
1283         return;
1284     }
1285
1286     @Override
1287     public void updateNode(Node node, UpdateType type, Set<Property> props) {
1288         switch (type) {
1289         case ADDED:
1290             addNode(node, props);
1291             break;
1292         case REMOVED:
1293             removeNode(node);
1294             break;
1295         default:
1296             break;
1297         }
1298     }
1299
1300     @Override
1301     public void updateNodeConnector(NodeConnector nodeConnector, UpdateType type, Set<Property> props) {
1302         Config config = null;
1303         State state = null;
1304         boolean enabled = false;
1305
1306         for (Property prop : props) {
1307             if (prop.getName().equals(Config.ConfigPropName)) {
1308                 config = (Config) prop;
1309             } else if (prop.getName().equals(State.StatePropName)) {
1310                 state = (State) prop;
1311             }
1312         }
1313         enabled = ((config != null) && (config.getValue() == Config.ADMIN_UP) && (state != null) && (state.getValue() == State.EDGE_UP));
1314
1315         switch (type) {
1316         case ADDED:
1317             if (enabled) {
1318                 addDiscovery(nodeConnector);
1319                 logger.trace("ADDED enabled {}", nodeConnector);
1320             } else {
1321                 logger.trace("ADDED disabled {}", nodeConnector);
1322             }
1323             break;
1324         case CHANGED:
1325             if (enabled) {
1326                 addDiscovery(nodeConnector);
1327                 logger.trace("CHANGED enabled {}", nodeConnector);
1328             } else {
1329                 removeDiscovery(nodeConnector);
1330                 logger.trace("CHANGED disabled {}", nodeConnector);
1331             }
1332             break;
1333         case REMOVED:
1334             removeDiscovery(nodeConnector);
1335             logger.trace("REMOVED enabled {}", nodeConnector);
1336             break;
1337         default:
1338             return;
1339         }
1340     }
1341
1342     public void addNode(Node node, Set<Property> props) {
1343         if (node == null) {
1344             return;
1345         }
1346
1347         addDiscovery(node);
1348     }
1349
1350     public void removeNode(Node node) {
1351         if (node == null) {
1352             return;
1353         }
1354
1355         removeDiscovery(node);
1356     }
1357
1358     void setController(IController s) {
1359         this.controller = s;
1360     }
1361
1362     void unsetController(IController s) {
1363         if (this.controller == s) {
1364             this.controller = null;
1365         }
1366     }
1367
1368     public void setInventoryProvider(IInventoryProvider service) {
1369         this.inventoryProvider = service;
1370     }
1371
1372     public void unsetInventoryProvider(IInventoryProvider service) {
1373         this.inventoryProvider = null;
1374     }
1375
1376     public void setIDataPacketMux(IDataPacketMux service) {
1377         this.iDataPacketMux = service;
1378     }
1379
1380     public void unsetIDataPacketMux(IDataPacketMux service) {
1381         if (this.iDataPacketMux == service) {
1382             this.iDataPacketMux = null;
1383         }
1384     }
1385
1386     void setDiscoveryListener(IDiscoveryListener s) {
1387         this.discoveryListener = s;
1388     }
1389
1390     void unsetDiscoveryListener(IDiscoveryListener s) {
1391         if (this.discoveryListener == s) {
1392             this.discoveryListener = null;
1393         }
1394     }
1395
1396     private void initDiscoveryPacket() {
1397         // Create LLDP ChassisID TLV
1398         chassisIdTlv = new LLDPTLV();
1399         chassisIdTlv.setType(LLDPTLV.TLVType.ChassisID.getValue());
1400
1401         // Create LLDP PortID TLV
1402         portIdTlv = new LLDPTLV();
1403         portIdTlv.setType(LLDPTLV.TLVType.PortID.getValue());
1404
1405         // Create LLDP TTL TLV
1406         byte[] ttl = new byte[] { (byte) 0, (byte) 120 };
1407         ttlTlv = new LLDPTLV();
1408         ttlTlv.setType(LLDPTLV.TLVType.TTL.getValue()).setLength((short) ttl.length).setValue(ttl);
1409
1410         customTlv = new LLDPTLV();
1411     }
1412
1413     /**
1414      * Function called by the dependency manager when all the required
1415      * dependencies are satisfied
1416      *
1417      */
1418     void init() {
1419         logger.trace("Init called");
1420
1421         transmitQ = new LinkedBlockingQueue<NodeConnector>();
1422
1423         readyListHi = new CopyOnWriteArrayList<NodeConnector>();
1424         readyListLo = new CopyOnWriteArrayList<NodeConnector>();
1425         stagingList = new CopyOnWriteArrayList<NodeConnector>();
1426         holdTime = new ConcurrentHashMap<NodeConnector, Integer>();
1427         elapsedTime = new ConcurrentHashMap<NodeConnector, Integer>();
1428         edgeMap = new ConcurrentHashMap<NodeConnector, Edge>();
1429         agingMap = new ConcurrentHashMap<NodeConnector, Integer>();
1430         prodMap = new ConcurrentHashMap<NodeConnector, Edge>();
1431         discoverySnoopingDisableList = new CopyOnWriteArrayList<NodeConnector>();
1432
1433         discoveryBatchRestartTicks = getDiscoveryInterval();
1434         discoveryBatchPauseTicks = getDiscoveryPauseInterval();
1435         discoveryTimeoutTicks = getDiscoveryTimeout();
1436         discoveryThresholdTicks = getDiscoveryThreshold();
1437         discoveryAgeoutTicks = getDiscoveryAgeout();
1438         discoveryConsistencyCheckTickCount = discoveryBatchPauseTicks;
1439         discoveryBatchMaxPorts = getDiscoveryBatchMaxPorts();
1440
1441         discoveryTimer = new Timer("DiscoveryService");
1442         discoveryTimerTask = new DiscoveryTimerTask();
1443
1444         transmitThread = new Thread(new DiscoveryTransmit(transmitQ));
1445
1446         initDiscoveryPacket();
1447
1448         registerWithOSGIConsole();
1449     }
1450
1451     /**
1452      * Function called by the dependency manager when at least one dependency
1453      * become unsatisfied or when the component is shutting down because for
1454      * example bundle is being stopped.
1455      *
1456      */
1457     void destroy() {
1458         transmitQ = null;
1459         readyListHi = null;
1460         readyListLo = null;
1461         stagingList = null;
1462         holdTime = null;
1463         edgeMap = null;
1464         agingMap = null;
1465         prodMap = null;
1466         discoveryTimer = null;
1467         discoveryTimerTask = null;
1468         transmitThread = null;
1469     }
1470
1471     /**
1472      * Function called by dependency manager after "init ()" is called and after
1473      * the services provided by the class are registered in the service registry
1474      *
1475      */
1476     void start() {
1477         discoveryTimer.schedule(discoveryTimerTask, discoveryTimerTick, discoveryTimerTick);
1478         transmitThread.start();
1479     }
1480
1481     /**
1482      * Function called after registering the service in OSGi service registry.
1483      */
1484     void started() {
1485         /* get a snapshot of all the existing switches */
1486         addDiscovery();
1487     }
1488
1489     /**
1490      * Function called by the dependency manager before the services exported by
1491      * the component are unregistered, this will be followed by a "destroy ()"
1492      * calls
1493      *
1494      */
1495     void stop() {
1496         shuttingDown = true;
1497         discoveryTimer.cancel();
1498         transmitThread.interrupt();
1499     }
1500
1501     @Override
1502     public void tagUpdated(String containerName, Node n, short oldTag, short newTag, UpdateType t) {
1503     }
1504
1505     @Override
1506     public void containerFlowUpdated(String containerName, ContainerFlow previousFlow, ContainerFlow currentFlow,
1507             UpdateType t) {
1508     }
1509
1510     @Override
1511     public void nodeConnectorUpdated(String containerName, NodeConnector p, UpdateType t) {
1512         switch (t) {
1513         case ADDED:
1514             moveToReadyListHi(p);
1515             break;
1516         default:
1517             break;
1518         }
1519     }
1520
1521     @Override
1522     public void containerModeUpdated(UpdateType t) {
1523         // do nothing
1524     }
1525
1526     private byte[] getSourceMACFromNodeID(String nodeId) {
1527         byte[] cid = HexEncode.bytesFromHexString(nodeId);
1528         byte[] sourceMac = new byte[6];
1529         int pos = cid.length - sourceMac.length;
1530
1531         if (pos >= 0) {
1532             System.arraycopy(cid, pos, sourceMac, 0, sourceMac.length);
1533         }
1534
1535         return sourceMac;
1536     }
1537
1538     private int getDiscoveryTicks(DiscoveryPeriod dp, String val) {
1539         if (dp == null) {
1540             return 0;
1541         }
1542
1543         if (val != null) {
1544             try {
1545                 dp.setTime(Integer.parseInt(val));
1546             } catch (Exception e) {
1547             }
1548         }
1549
1550         return dp.getTick();
1551     }
1552
1553     /**
1554      * This method returns the interval which determines how often the discovery
1555      * packets will be sent.
1556      *
1557      * @return The discovery interval in ticks
1558      */
1559     private int getDiscoveryInterval() {
1560         String intvl = System.getProperty("of.discoveryInterval");
1561         return getDiscoveryTicks(DiscoveryPeriod.INTERVAL, intvl);
1562     }
1563
1564     /**
1565      * This method returns the timeout value in receiving subsequent discovery packets on a port.
1566      *
1567      * @return The discovery timeout in ticks
1568      */
1569     private int getDiscoveryTimeout() {
1570         String val = System.getProperty("of.discoveryTimeoutMultiple");
1571         int multiple = 2;
1572
1573         if (val != null) {
1574             try {
1575                 multiple = Integer.parseInt(val);
1576             } catch (Exception e) {
1577             }
1578         }
1579         return getDiscoveryInterval() * multiple + 3;
1580     }
1581
1582     /**
1583      * This method returns the user configurable threshold value
1584      *
1585      * @return The discovery threshold value in ticks
1586      */
1587     private int getDiscoveryThreshold() {
1588         String val = System.getProperty("of.discoveryThreshold");
1589         return getDiscoveryTicks(DiscoveryPeriod.THRESHOLD, val);
1590     }
1591
1592     /**
1593      * This method returns the discovery entry aging time in ticks.
1594      *
1595      * @return The aging time in ticks
1596      */
1597     private int getDiscoveryAgeout() {
1598         return getDiscoveryTicks(DiscoveryPeriod.AGEOUT, null);
1599     }
1600
1601     /**
1602      * This method returns the pause interval
1603      *
1604      * @return The pause interval in ticks
1605      */
1606     private int getDiscoveryPauseInterval() {
1607         if (discoveryBatchRestartTicks > discoveryBatchPausePeriod) {
1608             return discoveryBatchRestartTicks - discoveryBatchPausePeriod;
1609         } else {
1610             return discoveryBatchRestartTicks - 1;
1611         }
1612     }
1613
1614     /**
1615      * This method returns the user configurable maximum number of ports handled
1616      * in one discovery batch.
1617      *
1618      * @return The maximum number of ports
1619      */
1620     private int getDiscoveryBatchMaxPorts() {
1621         String val = System.getProperty("of.discoveryBatchMaxPorts");
1622         int ports = 1024;
1623
1624         if (val != null) {
1625             try {
1626                 ports = Integer.parseInt(val);
1627             } catch (Exception e) {
1628             }
1629         }
1630         return ports;
1631     }
1632 }