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.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Set;
  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;
  24
  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;
  37
  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;
  61
  62 /**
  63  * The class describes neighbor discovery service for an OpenFlow network.
  64  */
  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;
  73
  74     private List<NodeConnector> readyListHi = null; // newly added ports go into
  75                                                     // this list and will be
  76                                                     // served first
  77     private List<NodeConnector> readyListLo = null; // come here after served at
  78                                                     // least once
  79     private List<NodeConnector> waitingList = null; // staging area during quiet
  80                                                     // period
  81     private ConcurrentMap<NodeConnector, Integer> pendingMap = null;// wait for
  82                                                                     // response
  83                                                                     // back
  84     private ConcurrentMap<NodeConnector, Edge> edgeMap = null; // openflow edges
  85                                                                // keyed by head
  86                                                                // connector
  87     private ConcurrentMap<NodeConnector, Integer> agingMap = null; // aging
  88                                                                    // entries
  89                                                                    // keyed by
  90                                                                    // edge port
  91     private ConcurrentMap<NodeConnector, Edge> prodMap = null; // production
  92                                                                // edges keyed by
  93                                                                // edge port
  94
  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
 100                                               // batch
 101     private int discoveryBatchRestartTicks = getDiscoveryInterval(); // periodically
 102                                                                      // restart
 103                                                                      // batching
 104                                                                      // process
 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
 109                                                       // initial timeout
 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
 115                                                                                // tick
 116                                                                                // counter
 117     private int discoveryConsistencyCheckCallingTimes = 0; // # of times CC gets
 118                                                            // called
 119     private int discoveryConsistencyCheckCorrected = 0; // # of cases CC
 120                                                         // corrected
 121     private boolean discoveryConsistencyCheckEnabled = true;// enable or disable
 122                                                             // CC
 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
 127                                                               // ports that will
 128                                                               // not do LLDP
 129                                                               // snooping
 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;
 134
 135     private LLDPTLV chassisIdTlv, portIdTlv, ttlTlv, customTlv;
 136
 137     class DiscoveryTransmit implements Runnable {
 138         private final BlockingQueue<NodeConnector> transmitQ;
 139
 140         DiscoveryTransmit(BlockingQueue<NodeConnector> transmitQ) {
 141             this.transmitQ = transmitQ;
 142         }
 143
 144         public void run() {
 145             while (true) {
 146                 try {
 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());
 153                     if (shuttingDown)
 154                         return;
 155                 } catch (Exception e2) {
 156                     logger.error("", e2);
 157                 }
 158             }
 159         }
 160     }
 161
 162     class DiscoveryTimerTask extends TimerTask {
 163         public void run() {
 164             checkTimeout();
 165             checkAging();
 166             doConsistencyCheck();
 167             doDiscovery();
 168         }
 169     }
 170
 171     private RawPacket createDiscoveryPacket(NodeConnector nodeConnector) {
 172         String nodeId = HexEncode.longToHexString((Long) nodeConnector
 173                 .getNode().getID());
 174
 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);
 179
 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);
 185
 186         // Create LLDP Custom TLV
 187         byte[] customValue = LLDPTLV.createCustomTLVValue(nodeConnector
 188                 .toString());
 189         customTlv.setType((byte) LLDPTLV.TLVType.Custom.getValue())
 190                 .setLength((short) customValue.length).setValue(customValue);
 191
 192         // Create LLDP Custom Option list
 193         List<LLDPTLV> customList = new ArrayList<LLDPTLV>();
 194         customList.add(customTlv);
 195
 196         // Create discovery pkt
 197         LLDP discoveryPkt = new LLDP();
 198         discoveryPkt.setChassisId(chassisIdTlv).setPortId(portIdTlv)
 199                 .setTtl(ttlTlv).setOptionalTLVList(customList);
 200
 201         RawPacket rawPkt = null;
 202         try {
 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);
 210
 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 {}",
 216                     cex.getMessage());
 217         } catch (Exception e) {
 218             logger.error("Failed to serialize the LLDP packet: " + e);
 219         }
 220
 221         return rawPkt;
 222     }
 223
 224     private void sendDiscoveryPacket(NodeConnector nodeConnector,
 225             RawPacket outPkt) {
 226         if (nodeConnector == null) {
 227             logger.debug("Can not send discovery packet out since nodeConnector is null");
 228             return;
 229         }
 230
 231         if (outPkt == null) {
 232             logger.debug("Can not send discovery packet out since outPkt is null");
 233             return;
 234         }
 235
 236         long sid = (Long) nodeConnector.getNode().getID();
 237         ISwitch sw = controller.getSwitches().get(sid);
 238
 239         if (sw == null) {
 240             logger.debug(
 241                     "Can not send discovery packet out since switch {} is null",
 242                     sid);
 243             return;
 244         }
 245
 246         if (!sw.isOperational()) {
 247             logger.debug(
 248                     "Can not send discovery packet out since switch {} is not operational",
 249                     sw);
 250             return;
 251         }
 252
 253         if (this.iDataPacketMux == null) {
 254             logger.debug("Can not send discovery packet out since DataPacket service is not available");
 255             return;
 256         }
 257
 258         logger.trace("Sending topology discovery pkt thru {}", nodeConnector);
 259         this.iDataPacketMux.transmitDataPacket(outPkt);
 260     }
 261
 262     @Override
 263     public PacketResult receiveDataPacket(RawPacket inPkt) {
 264         if (inPkt == null) {
 265             logger.debug("Ignoring null packet");
 266             return PacketResult.IGNORED;
 267         }
 268
 269         byte[] data = inPkt.getPacketData();
 270         if (data.length <= 0) {
 271             logger.trace("Ignoring zero length packet");
 272             return PacketResult.IGNORED;
 273         }
 274
 275         if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) {
 276             logger.trace("Ignoring non ethernet packet");
 277             return PacketResult.IGNORED;
 278         }
 279
 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;
 285         }
 286
 287         Ethernet ethPkt = new Ethernet();
 288         try {
 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;
 294         }
 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);
 300             }
 301             return PacketResult.CONSUME;
 302         }
 303         return PacketResult.IGNORED;
 304     }
 305
 306     /*
 307      * Snoop incoming discovery frames generated by the production network
 308      * neighbor switch
 309      */
 310     private void snoopDiscoveryPacket(NodeConnector dstNodeConnector,
 311             Ethernet ethPkt) {
 312         if (!this.discoverySnoopingEnabled
 313                 || discoverySnoopingDisableList.contains(dstNodeConnector)) {
 314             logger.trace(
 315                     "Discarded received discovery packet on {} since snooping is turned off",
 316                     dstNodeConnector);
 317             return;
 318         }
 319
 320         if ((dstNodeConnector == null) || (ethPkt == null)) {
 321             logger.trace("Quit snooping discovery packet: Null node connector or packet");
 322             return;
 323         }
 324
 325         LLDP lldp = (LLDP) ethPkt.getPayload();
 326
 327         try {
 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();
 337                     break;
 338                 }
 339             }
 340             String nodeName = (systemNameBytes == null) ? nodeId : new String(
 341                     systemNameBytes);
 342             Node srcNode = new Node(Node.NodeIDType.PRODUCTION, nodeName);
 343             NodeConnector srcNodeConnector = NodeConnectorCreator
 344                     .createNodeConnector(
 345                             NodeConnector.NodeConnectorIDType.PRODUCTION,
 346                             portId, srcNode);
 347
 348             Edge edge = null;
 349             Set<Property> props = null;
 350             edge = new Edge(srcNodeConnector, dstNodeConnector);
 351             props = getProps(dstNodeConnector);
 352
 353             updateProdEdge(edge, props);
 354         } catch (Exception e) {
 355             logger.warn("Caught exception ", e);
 356         }
 357     }
 358
 359     /*
 360      * Handle discovery frames generated by our controller
 361      *
 362      * @return true if it's a success
 363      */
 364     private boolean processDiscoveryPacket(NodeConnector dstNodeConnector,
 365             Ethernet ethPkt) {
 366         if ((dstNodeConnector == null) || (ethPkt == null)) {
 367             logger.trace("Ignoring processing of discovery packet: Null node connector or packet");
 368             return false;
 369         }
 370
 371         logger.trace("Handle discovery packet {} from {}", ethPkt,
 372                 dstNodeConnector);
 373
 374         LLDP lldp = (LLDP) ethPkt.getPayload();
 375
 376         List<LLDPTLV> optionalTLVList = lldp.getOptionalTLVList();
 377         if (optionalTLVList == null) {
 378             logger.info("The discovery packet with null custom option from {}",
 379                     dstNodeConnector);
 380             return false;
 381         }
 382
 383         Node srcNode = null;
 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)) {
 394                         break;
 395                     } else {
 396                         srcNode = null;
 397                         srcNodeConnector = null;
 398                     }
 399                 }
 400             }
 401         }
 402
 403         if ((srcNode == null) || (srcNodeConnector == null)) {
 404             logger.trace(
 405                     "Received non-controller generated discovery packet from {}",
 406                     dstNodeConnector);
 407             return false;
 408         }
 409
 410         // push it out to Topology
 411         Edge edge = null;
 412         Set<Property> props = null;
 413         try {
 414             edge = new Edge(srcNodeConnector, dstNodeConnector);
 415             props = getProps(dstNodeConnector);
 416         } catch (ConstructionException e) {
 417             logger.error("Caught exception ", e);
 418         }
 419         addEdge(edge, props);
 420
 421         logger.trace("Received discovery packet for Edge {}", edge);
 422
 423         return true;
 424     }
 425
 426     public Map<String, Property> getPropMap(NodeConnector nodeConnector) {
 427         if (nodeConnector == null) {
 428             return null;
 429         }
 430
 431         if (pluginInInventoryService == null) {
 432             return null;
 433         }
 434
 435         Map<NodeConnector, Map<String, Property>> props = pluginInInventoryService
 436                 .getNodeConnectorProps(false);
 437         if (props == null) {
 438             return null;
 439         }
 440
 441         return props.get(nodeConnector);
 442     }
 443
 444     public Property getProp(NodeConnector nodeConnector, String propName) {
 445         Map<String, Property> propMap = getPropMap(nodeConnector);
 446         if (propMap == null) {
 447             return null;
 448         }
 449
 450         Property prop = (Property) propMap.get(propName);
 451         return prop;
 452     }
 453
 454     public Set<Property> getProps(NodeConnector nodeConnector) {
 455         Map<String, Property> propMap = getPropMap(nodeConnector);
 456         if (propMap == null) {
 457             return null;
 458         }
 459
 460         Set<Property> props = new HashSet<Property>(propMap.values());
 461         return props;
 462     }
 463
 464     private boolean isEnabled(NodeConnector nodeConnector) {
 465         if (nodeConnector == null) {
 466             return false;
 467         }
 468
 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));
 473     }
 474
 475     private boolean isTracked(NodeConnector nodeConnector) {
 476         if (readyListHi.contains(nodeConnector)) {
 477             return true;
 478         }
 479
 480         if (readyListLo.contains(nodeConnector)) {
 481             return true;
 482         }
 483
 484         if (pendingMap.keySet().contains(nodeConnector)) {
 485             return true;
 486         }
 487
 488         if (waitingList.contains(nodeConnector)) {
 489             return true;
 490         }
 491
 492         return false;
 493     }
 494
 495     private Set<NodeConnector> getWorkingSet() {
 496         Set<NodeConnector> workingSet = new HashSet<NodeConnector>();
 497         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 498
 499         for (NodeConnector nodeConnector : readyListHi) {
 500             if (isOverLimit(workingSet.size())) {
 501                 break;
 502             }
 503
 504             workingSet.add(nodeConnector);
 505             removeSet.add(nodeConnector);
 506         }
 507         readyListHi.removeAll(removeSet);
 508
 509         removeSet.clear();
 510         for (NodeConnector nodeConnector : readyListLo) {
 511             if (isOverLimit(workingSet.size())) {
 512                 break;
 513             }
 514
 515             workingSet.add(nodeConnector);
 516             removeSet.add(nodeConnector);
 517         }
 518         readyListLo.removeAll(removeSet);
 519
 520         return workingSet;
 521     }
 522
 523     private Boolean isOverLimit(int size) {
 524         return ((size >= discoveryBatchMaxPorts) && !throttling);
 525     }
 526
 527     private void addDiscovery() {
 528         Map<Long, ISwitch> switches = controller.getSwitches();
 529         Set<Long> sidSet = switches.keySet();
 530         if (sidSet == null) {
 531             return;
 532         }
 533         for (Long sid : sidSet) {
 534             Node node = NodeCreator.createOFNode(sid);
 535             addDiscovery(node);
 536         }
 537     }
 538
 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();
 543         if (ports == null) {
 544             return;
 545         }
 546         for (OFPhysicalPort port : ports) {
 547             NodeConnector nodeConnector = NodeConnectorCreator
 548                     .createOFNodeConnector(port.getPortNumber(), node);
 549             if (!readyListHi.contains(nodeConnector)) {
 550                 readyListHi.add(nodeConnector);
 551             }
 552         }
 553     }
 554
 555     private void addDiscovery(NodeConnector nodeConnector) {
 556         if (isTracked(nodeConnector)) {
 557             return;
 558         }
 559
 560         readyListHi.add(nodeConnector);
 561     }
 562
 563     private Set<NodeConnector> getRemoveSet(Collection<NodeConnector> c,
 564             Node node) {
 565         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 566         if (c == null) {
 567             return removeSet;
 568         }
 569         for (NodeConnector nodeConnector : c) {
 570             if (node.equals(nodeConnector.getNode())) {
 571                 removeSet.add(nodeConnector);
 572             }
 573         }
 574         return removeSet;
 575     }
 576
 577     private void removeDiscovery(Node node) {
 578         Set<NodeConnector> removeSet;
 579
 580         removeSet = getRemoveSet(readyListHi, node);
 581         readyListHi.removeAll(removeSet);
 582
 583         removeSet = getRemoveSet(readyListLo, node);
 584         readyListLo.removeAll(removeSet);
 585
 586         removeSet = getRemoveSet(waitingList, node);
 587         waitingList.removeAll(removeSet);
 588
 589         removeSet = getRemoveSet(pendingMap.keySet(), node);
 590         for (NodeConnector nodeConnector : removeSet) {
 591             pendingMap.remove(nodeConnector);
 592         }
 593
 594         removeSet = getRemoveSet(edgeMap.keySet(), node);
 595         for (NodeConnector nodeConnector : removeSet) {
 596             removeEdge(nodeConnector, false);
 597         }
 598
 599         removeSet = getRemoveSet(prodMap.keySet(), node);
 600         for (NodeConnector nodeConnector : removeSet) {
 601             removeProdEdge(nodeConnector);
 602         }
 603     }
 604
 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);
 612     }
 613
 614     private void checkTimeout() {
 615         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 616         Set<NodeConnector> retrySet = new HashSet<NodeConnector>();
 617         int sentCount;
 618
 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()) {
 625                     // timeout the edge
 626                     removeSet.add(nodeConnector);
 627                     logger.trace("Discovery timeout {}", nodeConnector);
 628                 } else if (sentCount % discoveryTimeoutTicks == 0) {
 629                     retrySet.add(nodeConnector);
 630                 }
 631             }
 632         }
 633
 634         for (NodeConnector nodeConnector : removeSet) {
 635             removeEdge(nodeConnector);
 636         }
 637
 638         for (NodeConnector nodeConnector : retrySet) {
 639             transmitQ.add(nodeConnector);
 640         }
 641     }
 642
 643     private void checkAging() {
 644         if (!discoveryAgingEnabled) {
 645             return;
 646         }
 647
 648         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 649         int sentCount;
 650
 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) {
 657                     // age out the edge
 658                     removeSet.add(nodeConnector);
 659                     logger.trace("Discovery age out {}", nodeConnector);
 660                 }
 661             }
 662         }
 663
 664         for (NodeConnector nodeConnector : removeSet) {
 665             removeProdEdge(nodeConnector);
 666         }
 667     }
 668
 669     private void doDiscovery() {
 670         if (++discoveryTimerTickCount <= discoveryBatchPauseTicks) {
 671             for (NodeConnector nodeConnector : getWorkingSet()) {
 672                 pendingMap.put(nodeConnector, 0);
 673                 transmitQ.add(nodeConnector);
 674             }
 675         } else if (discoveryTimerTickCount >= discoveryBatchRestartTicks) {
 676             discoveryTimerTickCount = 0;
 677             for (NodeConnector nodeConnector : waitingList) {
 678                 if (!readyListLo.contains(nodeConnector))
 679                     readyListLo.add(nodeConnector);
 680             }
 681             waitingList.removeAll(readyListLo);
 682         }
 683     }
 684
 685     private void doConsistencyCheck() {
 686         if (!discoveryConsistencyCheckEnabled) {
 687             return;
 688         }
 689
 690         if (++discoveryConsistencyCheckTickCount
 691                 % getDiscoveryConsistencyCheckInterval() != 0) {
 692             return;
 693         }
 694
 695         discoveryConsistencyCheckCallingTimes++;
 696
 697         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 698         Set<NodeConnector> ncSet = edgeMap.keySet();
 699         if (ncSet == null) {
 700             return;
 701         }
 702         for (NodeConnector nodeConnector : ncSet) {
 703             if (!isEnabled(nodeConnector)) {
 704                 removeSet.add(nodeConnector);
 705                 discoveryConsistencyCheckCorrected++;
 706                 logger.debug("ConsistencyChecker: remove disabled {}",
 707                         nodeConnector);
 708                 continue;
 709             }
 710
 711             if (!isTracked(nodeConnector)) {
 712                 waitingList.add(nodeConnector);
 713                 discoveryConsistencyCheckCorrected++;
 714                 logger.debug("ConsistencyChecker: add back untracked {}",
 715                         nodeConnector);
 716                 continue;
 717             }
 718         }
 719
 720         for (NodeConnector nodeConnector : removeSet) {
 721             removeEdge(nodeConnector, false);
 722         }
 723
 724         // remove stale entries
 725         removeSet.clear();
 726         for (NodeConnector nodeConnector : waitingList) {
 727             if (!isEnabled(nodeConnector)) {
 728                 removeSet.add(nodeConnector);
 729                 discoveryConsistencyCheckCorrected++;
 730                 logger.debug("ConsistencyChecker: remove disabled {}",
 731                         nodeConnector);
 732             }
 733         }
 734         waitingList.removeAll(removeSet);
 735
 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 {}",
 747                             nodeConnector);
 748                 }
 749             }
 750         }
 751     }
 752
 753     private void addEdge(Edge edge, Set<Property> props) {
 754         if (edge == null) {
 755             return;
 756         }
 757
 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);
 763             }
 764         } else {
 765             NodeConnector dst = edge.getHeadNodeConnector();
 766             agingMap.put(dst, 0);
 767         }
 768
 769         // notify routeEngine
 770         updateEdge(edge, UpdateType.ADDED, props);
 771         logger.trace("Add edge {}", edge);
 772     }
 773
 774     /**
 775      * Update Production Edge
 776      *
 777      * @param edge
 778      *            The Production Edge
 779      * @param props
 780      *            Properties associated with the edge
 781      */
 782     private void updateProdEdge(Edge edge, Set<Property> props) {
 783         NodeConnector edgePort = edge.getHeadNodeConnector();
 784
 785         /* Do not update in case there is an existing OpenFlow link */
 786         if (edgeMap.get(edgePort) != null) {
 787             logger.trace(
 788                     "Discarded edge {} since there is an existing OF link {}",
 789                     edge, edgeMap.get(edgePort));
 790             return;
 791         }
 792
 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);
 803         } else {
 804             /* o/w, just reset the aging timer */
 805             NodeConnector dst = edge.getHeadNodeConnector();
 806             agingMap.put(dst, 0);
 807         }
 808     }
 809
 810     /**
 811      * Remove Production Edge for a given edge port
 812      *
 813      * @param edgePort
 814      *            The OF edge port
 815      */
 816     private void removeProdEdge(NodeConnector edgePort) {
 817         agingMap.remove(edgePort);
 818
 819         Edge edge = null;
 820         Set<NodeConnector> prodKeySet = prodMap.keySet();
 821         if ((prodKeySet != null) && (prodKeySet.contains(edgePort))) {
 822             edge = prodMap.get(edgePort);
 823             prodMap.remove(edgePort);
 824         }
 825
 826         // notify Topology
 827         if (this.discoveryService != null) {
 828             this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
 829         }
 830         logger.trace("Remove edge {}", edge);
 831     }
 832
 833     /*
 834      * Remove OpenFlow edge
 835      */
 836     private void removeEdge(NodeConnector nodeConnector, boolean stillEnabled) {
 837         pendingMap.remove(nodeConnector);
 838         readyListLo.remove(nodeConnector);
 839         readyListHi.remove(nodeConnector);
 840
 841         if (stillEnabled) {
 842             // keep discovering
 843             if (!waitingList.contains(nodeConnector)) {
 844                 waitingList.add(nodeConnector);
 845             }
 846         } else {
 847             // stop it
 848             waitingList.remove(nodeConnector);
 849         }
 850
 851         Edge edge = null;
 852         Set<NodeConnector> edgeKeySet = edgeMap.keySet();
 853         if ((edgeKeySet != null) && (edgeKeySet.contains(nodeConnector))) {
 854             edge = edgeMap.get(nodeConnector);
 855             edgeMap.remove(nodeConnector);
 856         }
 857
 858         // notify Topology
 859         if (this.discoveryService != null) {
 860             this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null);
 861         }
 862         logger.trace("Remove {}", nodeConnector);
 863     }
 864
 865     private void removeEdge(NodeConnector nodeConnector) {
 866         removeEdge(nodeConnector, isEnabled(nodeConnector));
 867     }
 868
 869     private void updateEdge(Edge edge, UpdateType type, Set<Property> props) {
 870         if (discoveryService == null) {
 871             return;
 872         }
 873
 874         this.discoveryService.notifyEdge(edge, type, props);
 875
 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);
 881             } else {
 882                 edgeMap.remove(dst);
 883             }
 884         } else {
 885             /*
 886              * Save Production edge into different DB keyed by the Edge port
 887              */
 888             if (type == UpdateType.ADDED) {
 889                 prodMap.put(dst, edge);
 890             } else {
 891                 prodMap.remove(dst);
 892             }
 893         }
 894     }
 895
 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);
 903         }
 904     }
 905
 906     private void registerWithOSGIConsole() {
 907         BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
 908                 .getBundleContext();
 909         bundleContext.registerService(CommandProvider.class.getName(), this,
 910                 null);
 911     }
 912
 913     private int getDiscoveryConsistencyCheckInterval() {
 914         return discoveryConsistencyCheckMultiple * discoveryBatchRestartTicks;
 915     }
 916
 917     private int getDiscoveryFinalTimeoutInterval() {
 918         return (discoveryRetry + 1) * discoveryTimeoutTicks;
 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 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();
 954     }
 955
 956     public void _prlh(CommandInterpreter ci) {
 957         ci.println("ReadyListHi\n");
 958         for (NodeConnector nodeConnector : readyListHi) {
 959             if (nodeConnector == null) {
 960                 continue;
 961             }
 962             ci.println(nodeConnector);
 963         }
 964     }
 965
 966     public void _prll(CommandInterpreter ci) {
 967         ci.println("ReadyListLo\n");
 968         for (NodeConnector nodeConnector : readyListLo) {
 969             if (nodeConnector == null) {
 970                 continue;
 971             }
 972             ci.println(nodeConnector);
 973         }
 974     }
 975
 976     public void _pwl(CommandInterpreter ci) {
 977         ci.println("WaitingList\n");
 978         for (NodeConnector nodeConnector : waitingList) {
 979             if (nodeConnector == null) {
 980                 continue;
 981             }
 982             ci.println(nodeConnector);
 983         }
 984     }
 985
 986     public void _ppl(CommandInterpreter ci) {
 987         ci.println("PendingList\n");
 988         for (NodeConnector nodeConnector : pendingMap.keySet()) {
 989             if (nodeConnector == null) {
 990                 continue;
 991             }
 992             ci.println(nodeConnector);
 993         }
 994     }
 995
 996     public void _ptick(CommandInterpreter ci) {
 997         ci.println("Current timer is " + discoveryTimerTick + " msec per tick");
 998     }
 999
1000     public void _pcc(CommandInterpreter ci) {
1001         if (discoveryConsistencyCheckEnabled) {
1002             ci.println("ConsistencyChecker is currently enabled");
1003         } else {
1004             ci.println("ConsistencyChecker is currently disabled");
1005         }
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);
1011     }
1012
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);
1017     }
1018
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());
1026     }
1027
1028     public void _page(CommandInterpreter ci) {
1029         if (this.discoveryAgingEnabled) {
1030             ci.println("Aging is enabled");
1031         } else {
1032             ci.println("Aging is disabled");
1033         }
1034         ci.println("Current aging time limit " + this.discoveryAgeoutTicks);
1035         ci.println("\n");
1036         ci.println("                           Edge                                 Aging ");
1037         Collection<Edge> prodSet = prodMap.values();
1038         if (prodSet == null) {
1039             return;
1040         }
1041         for (Edge edge : prodSet) {
1042             Integer aging = agingMap.get(edge.getHeadNodeConnector());
1043             if (aging != null) {
1044                 ci.println(edge + "      " + aging);
1045             }
1046         }
1047         ci.println("\n");
1048         ci.println("              NodeConnector                                                 Edge ");
1049         Set<NodeConnector> keySet = prodMap.keySet();
1050         if (keySet == null) {
1051             return;
1052         }
1053         for (NodeConnector nc : keySet) {
1054             ci.println(nc + "      " + prodMap.get(nc));
1055         }
1056         return;
1057     }
1058
1059     public void _sage(CommandInterpreter ci) {
1060         String val = ci.nextArgument();
1061         if (val == null) {
1062             ci.println("Please enter aging time limit. Current value "
1063                     + this.discoveryAgeoutTicks);
1064             return;
1065         }
1066         try {
1067             this.discoveryAgeoutTicks = Integer.parseInt(val);
1068         } catch (Exception e) {
1069             ci.println("Please enter a valid number");
1070         }
1071         return;
1072     }
1073
1074     public void _eage(CommandInterpreter ci) {
1075         this.discoveryAgingEnabled = true;
1076         ci.println("Aging is enabled");
1077         return;
1078     }
1079
1080     public void _dage(CommandInterpreter ci) {
1081         this.discoveryAgingEnabled = false;
1082         ci.println("Aging is disabled");
1083         return;
1084     }
1085
1086     public void _scc(CommandInterpreter ci) {
1087         String val = ci.nextArgument();
1088         if (val == null) {
1089             ci.println("Please enter CC multiple. Current multiple "
1090                     + discoveryConsistencyCheckMultiple + " (interval "
1091                     + getDiscoveryConsistencyCheckInterval()
1092                     + ") calling times "
1093                     + discoveryConsistencyCheckCallingTimes);
1094             return;
1095         }
1096         try {
1097             discoveryConsistencyCheckMultiple = Integer.parseInt(val);
1098         } catch (Exception e) {
1099             ci.println("Please enter a valid number");
1100         }
1101         return;
1102     }
1103
1104     public void _ecc(CommandInterpreter ci) {
1105         this.discoveryConsistencyCheckEnabled = true;
1106         ci.println("ConsistencyChecker is enabled");
1107         return;
1108     }
1109
1110     public void _dcc(CommandInterpreter ci) {
1111         this.discoveryConsistencyCheckEnabled = false;
1112         ci.println("ConsistencyChecker is disabled");
1113         return;
1114     }
1115
1116     public void _psnp(CommandInterpreter ci) {
1117         if (this.discoverySnoopingEnabled) {
1118             ci.println("Discovery snooping is globally enabled");
1119         } else {
1120             ci.println("Discovery snooping is globally disabled");
1121         }
1122
1123         ci.println("\nDiscovery snooping is locally disabled on these ports");
1124         for (NodeConnector nodeConnector : discoverySnoopingDisableList) {
1125             ci.println(nodeConnector);
1126         }
1127         return;
1128     }
1129
1130     public void _esnp(CommandInterpreter ci) {
1131         String val = ci.nextArgument();
1132
1133         if (val == null) {
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");
1138         } else {
1139             NodeConnector nodeConnector = NodeConnector.fromString(val);
1140             if (nodeConnector != null) {
1141                 discoverySnoopingDisableList.remove(nodeConnector);
1142                 ci.println("Discovery snooping is locally enabled on port "
1143                         + nodeConnector);
1144             } else {
1145                 ci.println("Entered invalid NodeConnector " + val);
1146             }
1147         }
1148         return;
1149     }
1150
1151     public void _dsnp(CommandInterpreter ci) {
1152         String val = ci.nextArgument();
1153
1154         if (val == null) {
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");
1159         } else {
1160             NodeConnector nodeConnector = NodeConnector.fromString(val);
1161             if (nodeConnector != null) {
1162                 discoverySnoopingDisableList.add(nodeConnector);
1163                 ci.println("Discovery snooping is locally disabled on port "
1164                         + nodeConnector);
1165             } else {
1166                 ci.println("Entered invalid NodeConnector " + val);
1167             }
1168         }
1169         return;
1170     }
1171
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 + ".";
1178
1179         if (val != null) {
1180             try {
1181                 int pause = Integer.parseInt(val);
1182                 if (pause < discoveryBatchRestartTicks) {
1183                     discoveryBatchPausePeriod = pause;
1184                     discoveryBatchPauseTicks = discoveryBatchRestartTicks
1185                             - discoveryBatchPausePeriod;
1186                     return;
1187                 }
1188             } catch (Exception e) {
1189             }
1190         }
1191
1192         ci.println(out);
1193     }
1194
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 + ".";
1200
1201         if (val != null) {
1202             try {
1203                 int restart = Integer.parseInt(val);
1204                 if (restart > discoveryBatchPausePeriod) {
1205                     discoveryBatchRestartTicks = restart;
1206                     discoveryBatchPauseTicks = discoveryBatchRestartTicks
1207                             - discoveryBatchPausePeriod;
1208                     return;
1209                 }
1210             } catch (Exception e) {
1211             }
1212         }
1213         ci.println(out);
1214     }
1215
1216     public void _sports(CommandInterpreter ci) {
1217         String val = ci.nextArgument();
1218         if (val == null) {
1219             ci.println("Please enter max ports per batch. Current value is "
1220                     + discoveryBatchMaxPorts);
1221             return;
1222         }
1223         try {
1224             discoveryBatchMaxPorts = Integer.parseInt(val);
1225         } catch (Exception e) {
1226             ci.println("Please enter a valid number");
1227         }
1228         return;
1229     }
1230
1231     public void _sretry(CommandInterpreter ci) {
1232         String val = ci.nextArgument();
1233         if (val == null) {
1234             ci.println("Please enter number of retries. Current value is "
1235                     + discoveryRetry);
1236             return;
1237         }
1238         try {
1239             discoveryRetry = Integer.parseInt(val);
1240         } catch (Exception e) {
1241             ci.println("Please enter a valid number");
1242         }
1243         return;
1244     }
1245
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;
1251         if (val != null) {
1252             try {
1253                 int timeout = Integer.parseInt(val);
1254                 if (timeout < discoveryBatchRestartTicks) {
1255                     discoveryTimeoutTicks = timeout;
1256                     return;
1257                 }
1258             } catch (Exception e) {
1259             }
1260         }
1261
1262         ci.println(out);
1263     }
1264
1265     public void _addsw(CommandInterpreter ci) {
1266         String val = ci.nextArgument();
1267         Long sid;
1268         try {
1269             sid = Long.parseLong(val);
1270             Node node = NodeCreator.createOFNode(sid);
1271             addDiscovery(node);
1272         } catch (Exception e) {
1273             ci.println("Please enter a valid number");
1274         }
1275         return;
1276     }
1277
1278     public void _remsw(CommandInterpreter ci) {
1279         String val = ci.nextArgument();
1280         Long sid;
1281         try {
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");
1287         }
1288         return;
1289     }
1290
1291     public void _pthrot(CommandInterpreter ci) {
1292         if (this.throttling) {
1293             ci.println("Throttling is enabled");
1294         } else {
1295             ci.println("Throttling is disabled");
1296         }
1297     }
1298
1299     public void _ethrot(CommandInterpreter ci) {
1300         this.throttling = true;
1301         ci.println("Throttling is enabled");
1302         return;
1303     }
1304
1305     public void _dthrot(CommandInterpreter ci) {
1306         this.throttling = false;
1307         ci.println("Throttling is disabled");
1308         return;
1309     }
1310
1311     @Override
1312     public void updateNode(Node node, UpdateType type, Set<Property> props) {
1313         switch (type) {
1314         case ADDED:
1315             addNode(node, props);
1316             break;
1317         case REMOVED:
1318             removeNode(node);
1319             break;
1320         default:
1321             break;
1322         }
1323     }
1324
1325     @Override
1326     public void updateNodeConnector(NodeConnector nodeConnector,
1327             UpdateType type, Set<Property> props) {
1328         Config config = null;
1329         State state = null;
1330         boolean enabled = false;
1331
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;
1337             }
1338         }
1339         enabled = ((config != null) && (config.getValue() == Config.ADMIN_UP)
1340                 && (state != null) && (state.getValue() == State.EDGE_UP));
1341
1342         switch (type) {
1343         case ADDED:
1344             if (enabled) {
1345                 addDiscovery(nodeConnector);
1346                 logger.trace("ADDED enabled {}", nodeConnector);
1347             } else {
1348                 logger.trace("ADDED disabled {}", nodeConnector);
1349             }
1350             break;
1351         case CHANGED:
1352             if (enabled) {
1353                 addDiscovery(nodeConnector);
1354                 logger.trace("CHANGED enabled {}", nodeConnector);
1355             } else {
1356                 removeDiscovery(nodeConnector);
1357                 logger.trace("CHANGED disabled {}", nodeConnector);
1358             }
1359             break;
1360         case REMOVED:
1361             removeDiscovery(nodeConnector);
1362             logger.trace("REMOVED enabled {}", nodeConnector);
1363             break;
1364         default:
1365             return;
1366         }
1367     }
1368
1369     public void addNode(Node node, Set<Property> props) {
1370         if (node == null)
1371             return;
1372
1373         addDiscovery(node);
1374     }
1375
1376     public void removeNode(Node node) {
1377         if (node == null)
1378             return;
1379
1380         removeDiscovery(node);
1381     }
1382
1383     public void updateNode(Node node, Set<Property> props) {
1384     }
1385
1386     void setController(IController s) {
1387         this.controller = s;
1388     }
1389
1390     void unsetController(IController s) {
1391         if (this.controller == s) {
1392             this.controller = null;
1393         }
1394     }
1395
1396     public void setPluginInInventoryService(IPluginInInventoryService service) {
1397         this.pluginInInventoryService = service;
1398     }
1399
1400     public void unsetPluginInInventoryService(IPluginInInventoryService service) {
1401         this.pluginInInventoryService = null;
1402     }
1403
1404     public void setIDataPacketMux(IDataPacketMux service) {
1405         this.iDataPacketMux = service;
1406     }
1407
1408     public void unsetIDataPacketMux(IDataPacketMux service) {
1409         if (this.iDataPacketMux == service) {
1410             this.iDataPacketMux = null;
1411         }
1412     }
1413
1414     void setDiscoveryService(IDiscoveryService s) {
1415         this.discoveryService = s;
1416     }
1417
1418     void unsetDiscoveryService(IDiscoveryService s) {
1419         if (this.discoveryService == s) {
1420             this.discoveryService = null;
1421         }
1422     }
1423
1424     private void initDiscoveryPacket() {
1425         // Create LLDP ChassisID TLV
1426         chassisIdTlv = new LLDPTLV();
1427         chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue());
1428
1429         // Create LLDP PortID TLV
1430         portIdTlv = new LLDPTLV();
1431         portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue());
1432
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);
1438
1439         customTlv = new LLDPTLV();
1440     }
1441
1442     /**
1443      * Function called by the dependency manager when all the required
1444      * dependencies are satisfied
1445      *
1446      */
1447     void init() {
1448         logger.trace("Init called");
1449
1450         transmitQ = new LinkedBlockingQueue<NodeConnector>();
1451
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>();
1460
1461         discoveryTimer = new Timer("DiscoveryService");
1462         discoveryTimerTask = new DiscoveryTimerTask();
1463
1464         transmitThread = new Thread(new DiscoveryTransmit(transmitQ));
1465
1466         initDiscoveryPacket();
1467
1468         registerWithOSGIConsole();
1469     }
1470
1471     /**
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.
1475      *
1476      */
1477     void destroy() {
1478         transmitQ = null;
1479         readyListHi = null;
1480         readyListLo = null;
1481         waitingList = null;
1482         pendingMap = null;
1483         edgeMap = null;
1484         agingMap = null;
1485         prodMap = null;
1486         discoveryTimer = null;
1487         discoveryTimerTask = null;
1488         transmitThread = null;
1489     }
1490
1491     /**
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
1494      *
1495      */
1496     void start() {
1497         discoveryTimer.schedule(discoveryTimerTask, discoveryTimerTick,
1498                 discoveryTimerTick);
1499         transmitThread.start();
1500     }
1501
1502     /**
1503      * Function called after registering the service in OSGi service registry.
1504      */
1505     void started() {
1506         /* get a snapshot of all the existing switches */
1507         addDiscovery();
1508     }
1509
1510     /**
1511      * Function called by the dependency manager before the services exported by
1512      * the component are unregistered, this will be followed by a "destroy ()"
1513      * calls
1514      *
1515      */
1516     void stop() {
1517         shuttingDown = true;
1518         discoveryTimer.cancel();
1519         transmitThread.interrupt();
1520     }
1521
1522     @Override
1523     public void tagUpdated(String containerName, Node n, short oldTag,
1524             short newTag, UpdateType t) {
1525     }
1526
1527     @Override
1528     public void containerFlowUpdated(String containerName,
1529             ContainerFlow previousFlow, ContainerFlow currentFlow, UpdateType t) {
1530     }
1531
1532     @Override
1533     public void nodeConnectorUpdated(String containerName, NodeConnector p,
1534             UpdateType t) {
1535         switch (t) {
1536         case ADDED:
1537             moreToReadyListHi(p);
1538             break;
1539         default:
1540             break;
1541         }
1542     }
1543
1544     @Override
1545     public void containerModeUpdated(UpdateType t) {
1546         // do nothing
1547     }
1548
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;
1553
1554         if (pos >= 0) {
1555             System.arraycopy(cid, pos, sourceMac, 0, sourceMac.length);
1556         }
1557
1558         return sourceMac;
1559     }
1560
1561     /**
1562      * This method returns the interval which determines how often the discovery
1563      * packets will be sent. Default is 300 seconds.
1564      *
1565      * @return The discovery interval in second
1566      */
1567     private int getDiscoveryInterval() {
1568         String elapsedTime = System.getProperty("of.discoveryInterval");
1569         int rv = 300;
1570
1571         try {
1572             if (elapsedTime != null) {
1573                 rv = Integer.parseInt(elapsedTime);
1574             }
1575         } catch (Exception e) {
1576         }
1577
1578         return rv;
1579     }
1580
1581     /**
1582      * This method returns the timeout value in waiting for response of a
1583      * discovery query. Default is 60 seconds.
1584      *
1585      * @return The discovery timeout in second
1586      */
1587     private int getDiscoveryTimeout() {
1588         String elapsedTime = System.getProperty("of.discoveryTimeout");
1589         int rv = 60;
1590
1591         try {
1592             if (elapsedTime != null) {
1593                 rv = Integer.parseInt(elapsedTime);
1594             }
1595         } catch (Exception e) {
1596         }
1597
1598         return rv;
1599     }
1600
1601     /**
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.
1604      *
1605      * @return The number of discovery retries
1606      */
1607     private int getDiscoveryRetry() {
1608         String retry = System.getProperty("of.discoveryRetry");
1609         int rv = 2;
1610
1611         if (retry != null) {
1612             try {
1613                 rv = Integer.parseInt(retry);
1614             } catch (Exception e) {
1615             }
1616         }
1617
1618         return rv;
1619     }
1620 }