X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fprotocol_plugins%2Fopenflow_netty%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fprotocol_plugin%2Fopenflow%2Finternal%2FDiscoveryService.java;fp=opendaylight%2Fprotocol_plugins%2Fopenflow_netty%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fprotocol_plugin%2Fopenflow%2Finternal%2FDiscoveryService.java;h=0000000000000000000000000000000000000000;hb=9f1c9e42abe1546fe352a9960935271f47f9a775;hp=972d1c0f439c5178b679032ff077b31d09cdd197;hpb=85073423c6069e4b58fffde7cf19c806b2b52dd5;p=controller.git diff --git a/opendaylight/protocol_plugins/openflow_netty/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/DiscoveryService.java b/opendaylight/protocol_plugins/openflow_netty/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/DiscoveryService.java deleted file mode 100644 index 972d1c0f43..0000000000 --- a/opendaylight/protocol_plugins/openflow_netty/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/DiscoveryService.java +++ /dev/null @@ -1,1518 +0,0 @@ - -/* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.controller.protocol_plugin.openflow.internal; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.Timer; -import java.util.TimerTask; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.CopyOnWriteArrayList; -import java.util.concurrent.LinkedBlockingQueue; - -import org.eclipse.osgi.framework.console.CommandInterpreter; -import org.eclipse.osgi.framework.console.CommandProvider; -import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketListen; -import org.opendaylight.controller.protocol_plugin.openflow.IDataPacketMux; -import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimExternalListener; -import org.opendaylight.controller.protocol_plugin.openflow.core.IController; -import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch; -import org.openflow.protocol.OFPhysicalPort; -import org.osgi.framework.BundleContext; -import org.osgi.framework.FrameworkUtil; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.opendaylight.controller.sal.core.Config; -import org.opendaylight.controller.sal.core.ConstructionException; -import org.opendaylight.controller.sal.core.Edge; -import org.opendaylight.controller.sal.core.ContainerFlow; -import org.opendaylight.controller.sal.core.IContainerListener; -import org.opendaylight.controller.sal.core.Node; -import org.opendaylight.controller.sal.core.NodeConnector; -import org.opendaylight.controller.sal.core.Property; -import org.opendaylight.controller.sal.core.State; -import org.opendaylight.controller.sal.core.UpdateType; -import org.opendaylight.controller.sal.discovery.IDiscoveryService; -import org.opendaylight.controller.sal.inventory.IPluginInInventoryService; -import org.opendaylight.controller.sal.packet.Ethernet; -import org.opendaylight.controller.sal.packet.LLDP; -import org.opendaylight.controller.sal.packet.LLDPTLV; -import org.opendaylight.controller.sal.packet.LinkEncap; -import org.opendaylight.controller.sal.packet.PacketResult; -import org.opendaylight.controller.sal.packet.RawPacket; -import org.opendaylight.controller.sal.utils.EtherTypes; -import org.opendaylight.controller.sal.utils.HexEncode; -import org.opendaylight.controller.sal.utils.NetUtils; -import org.opendaylight.controller.sal.utils.NodeConnectorCreator; -import org.opendaylight.controller.sal.utils.NodeCreator; - -/** - * The class describes neighbor discovery service for an OpenFlow network. - */ -public class DiscoveryService implements IInventoryShimExternalListener, - IDataPacketListen, IContainerListener, CommandProvider { - private static Logger logger = LoggerFactory - .getLogger(DiscoveryService.class); - private IController controller = null; - private IDiscoveryService discoveryService = null; - private IPluginInInventoryService pluginInInventoryService = null; - private IDataPacketMux iDataPacketMux = null; - - private List readyListHi = null; // newly added ports go into this list and will be served first - private List readyListLo = null; // come here after served at least once - private List waitingList = null; // staging area during quiet period - private ConcurrentMap pendingMap = null;// wait for response back - private ConcurrentMap edgeMap = null; // openflow edges keyed by head connector - private ConcurrentMap agingMap = null; // aging entries keyed by edge port - private ConcurrentMap prodMap = null; // production edges keyed by edge port - - private Timer discoveryTimer; // discovery timer - private DiscoveryTimerTask discoveryTimerTask; // timer task - private long discoveryTimerTick = 1L * 1000; // per tick in msec - private int discoveryTimerTickCount = 0; // main tick counter - private int discoveryBatchMaxPorts = 500; // max # of ports handled in one batch - private int discoveryBatchRestartTicks = getDiscoveryInterval(); // periodically restart batching process - private int discoveryBatchPausePeriod = 5; // pause for few secs - private int discoveryBatchPauseTicks = discoveryBatchRestartTicks - discoveryBatchPausePeriod; // pause after this point - private int discoveryRetry = 2; // number of retry after initial timeout - private int discoveryTimeoutTicks = getDiscoveryTimeout(); // timeout in sec - private int discoveryAgeoutTicks = 120; // age out 2 min - private int discoveryConsistencyCheckMultiple = 2; // multiple of discoveryBatchRestartTicks - private int discoveryConsistencyCheckTickCount = discoveryBatchPauseTicks; // CC tick counter - private int discoveryConsistencyCheckCallingTimes = 0; // # of times CC gets called - private int discoveryConsistencyCheckCorrected = 0; // # of cases CC corrected - private boolean discoveryConsistencyCheckEnabled = true;// enable or disable CC - private boolean discoveryAgingEnabled = true; // enable or disable aging - private boolean discoverySpoofingEnabled = true; // enable or disable spoofing neighbor of a production network - - private BlockingQueue transmitQ; - private Thread transmitThread; - private Boolean throttling = false; // if true, no more batching. - private volatile Boolean shuttingDown = false; - - private LLDPTLV chassisIdTlv, portIdTlv, ttlTlv, customTlv; - - class DiscoveryTransmit implements Runnable { - private final BlockingQueue transmitQ; - - DiscoveryTransmit(BlockingQueue transmitQ) { - this.transmitQ = transmitQ; - } - - public void run() { - while (true) { - try { - NodeConnector nodeConnector = transmitQ.take(); - RawPacket outPkt = createDiscoveryPacket(nodeConnector); - sendDiscoveryPacket(nodeConnector, outPkt); - nodeConnector = null; - } catch (InterruptedException e1) { - logger - .warn("DiscoveryTransmit interupted", e1 - .getMessage()); - if (shuttingDown) - return; - } catch (Exception e2) { - logger.error("",e2); - } - } - } - } - - class DiscoveryTimerTask extends TimerTask { - public void run() { - checkTimeout(); - checkAging(); - doConsistencyCheck(); - doDiscovery(); - } - } - - private RawPacket createDiscoveryPacket(NodeConnector nodeConnector) { - String nodeId = HexEncode.longToHexString((Long) nodeConnector - .getNode().getID()); - - // Create LLDP ChassisID TLV - byte[] cidValue = LLDPTLV.createChassisIDTLVValue(nodeId); - chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue()) - .setLength((short) cidValue.length).setValue(cidValue); - - // Create LLDP PortID TLV - String portId = nodeConnector.getNodeConnectorIDString(); - byte[] pidValue = LLDPTLV.createPortIDTLVValue(portId); - portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue()) - .setLength((short) pidValue.length).setValue(pidValue); - - // Create LLDP Custom TLV - byte[] customValue = LLDPTLV.createCustomTLVValue(nodeConnector.toString()); - customTlv.setType((byte) LLDPTLV.TLVType.Custom.getValue()) - .setLength((short) customValue.length).setValue(customValue); - - // Create LLDP Custom Option list - List customList = new ArrayList(); - customList.add(customTlv); - - // Create discovery pkt - LLDP discoveryPkt = new LLDP(); - discoveryPkt.setChassisId(chassisIdTlv).setPortId(portIdTlv).setTtl( - ttlTlv).setOptionalTLVList(customList); - - RawPacket rawPkt = null; - try { - // Create ethernet pkt - byte[] sourceMac = getSouceMACFromNodeID(nodeId); - Ethernet ethPkt = new Ethernet(); - ethPkt.setSourceMACAddress(sourceMac).setDestinationMACAddress( - LLDP.LLDPMulticastMac).setEtherType( - EtherTypes.LLDP.shortValue()).setPayload(discoveryPkt); - - byte[] data = ethPkt.serialize(); - rawPkt = new RawPacket(data); - rawPkt.setOutgoingNodeConnector(nodeConnector); - } catch (ConstructionException cex) { - logger.warn("RawPacket creation caught exception {}", cex - .getMessage()); - } catch (Exception e) { - logger.error("Failed to serialize the LLDP packet: " + e); - } - - return rawPkt; - } - - private void sendDiscoveryPacket(NodeConnector nodeConnector, - RawPacket outPkt) { - if (nodeConnector == null) { - logger.debug("Can not send discovery packet out since nodeConnector is null"); - return; - } - - if (outPkt == null) { - logger.debug("Can not send discovery packet out since outPkt is null"); - return; - } - - long sid = (Long) nodeConnector.getNode().getID(); - ISwitch sw = controller.getSwitches().get(sid); - - if (sw == null) { - logger.debug("Can not send discovery packet out since switch {} is null", sid); - return; - } - - if (!sw.isOperational()) { - logger.debug("Can not send discovery packet out since switch {} is not operational", sw); - return; - } - - if (this.iDataPacketMux == null) { - logger.debug("Can not send discovery packet out since DataPacket service is not available"); - return; - } - - logger.trace("Sending topology discovery pkt thru {}", nodeConnector); - this.iDataPacketMux.transmitDataPacket(outPkt); - } - - @Override - public PacketResult receiveDataPacket(RawPacket inPkt) { - if (inPkt == null) { - logger.debug("Ignoring null packet"); - return PacketResult.IGNORED; - } - - byte[] data = inPkt.getPacketData(); - if (data.length <= 0) { - logger.trace("Ignoring zero length packet"); - return PacketResult.IGNORED; - } - - if (!inPkt.getEncap().equals(LinkEncap.ETHERNET)) { - logger.trace("Ignoring non ethernet packet"); - return PacketResult.IGNORED; - } - - if (((Short) inPkt.getIncomingNodeConnector().getID()) - .equals(NodeConnector.SPECIALNODECONNECTORID)) { - logger.trace("Ignoring ethernet packet received on special port: " - + inPkt.getIncomingNodeConnector().toString()); - return PacketResult.IGNORED; - } - - Ethernet ethPkt = new Ethernet(); - try { - ethPkt.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte); - } catch (Exception e) { - logger.warn("Failed to decode LLDP packet from {}: {}", - inPkt.getIncomingNodeConnector(), e); - return PacketResult.IGNORED; - } - if (ethPkt.getPayload() instanceof LLDP) { - NodeConnector dst = inPkt.getIncomingNodeConnector(); - if (!processDiscoveryPacket(dst, ethPkt)) { - /* Spoof the discovery pkt if not generated from us */ - spoofDiscoveryPacket(dst, ethPkt); - } - return PacketResult.CONSUME; - } - return PacketResult.IGNORED; - } - - /* - * Spoof incoming discovery frames generated by the production network neighbor switch - */ - private void spoofDiscoveryPacket(NodeConnector dstNodeConnector, - Ethernet ethPkt) { - if (!this.discoverySpoofingEnabled) { - return; - } - - if ((dstNodeConnector == null) || (ethPkt == null)) { - logger.trace("Quit spoofing discovery packet: Null node connector or packet"); - return; - } - - LLDP lldp = (LLDP) ethPkt.getPayload(); - - try { - String nodeId = LLDPTLV.getHexStringValue(lldp.getChassisId().getValue(), lldp.getChassisId().getLength()); - String portId = LLDPTLV.getStringValue(lldp.getPortId().getValue(), lldp.getPortId().getLength()); - byte[] systemNameBytes = null; - // get system name if present in the LLDP pkt - for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) { - if (lldptlv.getType() == LLDPTLV.TLVType.SystemName.getValue()) { - systemNameBytes = lldptlv.getValue(); - break; - } - } - String nodeName = (systemNameBytes == null) ? nodeId : new String(systemNameBytes); - Node srcNode = new Node(Node.NodeIDType.PRODUCTION, nodeName); - NodeConnector srcNodeConnector = NodeConnectorCreator - .createNodeConnector(NodeConnector.NodeConnectorIDType.PRODUCTION, - portId, srcNode); - - Edge edge = null; - Set props = null; - edge = new Edge(srcNodeConnector, dstNodeConnector); - props = getProps(dstNodeConnector); - - updateProdEdge(edge, props); - } catch (Exception e) { - logger.warn("Caught exception ", e); - } - } - - /* - * Handle discovery frames generated by our controller - * @return true if it's a success - */ - private boolean processDiscoveryPacket(NodeConnector dstNodeConnector, - Ethernet ethPkt) { - if ((dstNodeConnector == null) || (ethPkt == null)) { - logger - .trace("Ignoring processing of discovery packet: Null node connector or packet"); - return false; - } - - logger.trace("Handle discovery packet {} from {}", ethPkt, - dstNodeConnector); - - LLDP lldp = (LLDP) ethPkt.getPayload(); - - List optionalTLVList = lldp.getOptionalTLVList(); - if (optionalTLVList == null) { - logger.info("The discovery packet with null custom option from {}", - dstNodeConnector); - return false; - } - - Node srcNode = null; - NodeConnector srcNodeConnector = null; - for (LLDPTLV lldptlv : lldp.getOptionalTLVList()) { - if (lldptlv.getType() == LLDPTLV.TLVType.Custom.getValue()) { - String ncString = LLDPTLV.getCustomString(lldptlv.getValue(), lldptlv.getLength()); - srcNodeConnector = NodeConnector.fromString(ncString); - if (srcNodeConnector != null) { - srcNode = srcNodeConnector.getNode(); - /* Check if it's expected */ - if (isTracked(srcNodeConnector)) { - break; - } else { - srcNode = null; - srcNodeConnector = null; - } - } - } - } - - if ((srcNode == null) || (srcNodeConnector == null)) { - logger - .trace( - "Received non-controller generated discovery packet from {}", - dstNodeConnector); - return false; - } - - // push it out to Topology - Edge edge = null; - Set props = null; - try { - edge = new Edge(srcNodeConnector, dstNodeConnector); - props = getProps(dstNodeConnector); - } catch (ConstructionException e) { - logger.error("Caught exception ", e); - } - addEdge(edge, props); - - logger.trace("Received discovery packet for Edge {}", edge); - - return true; - } - - public Map getPropMap(NodeConnector nodeConnector) { - if (nodeConnector == null) { - return null; - } - - if (pluginInInventoryService == null) { - return null; - } - - Map> props = pluginInInventoryService - .getNodeConnectorProps(false); - if (props == null) { - return null; - } - - return props.get(nodeConnector); - } - - public Property getProp(NodeConnector nodeConnector, String propName) { - Map propMap = getPropMap(nodeConnector); - if (propMap == null) { - return null; - } - - Property prop = (Property) propMap.get(propName); - return prop; - } - - public Set getProps(NodeConnector nodeConnector) { - Map propMap = getPropMap(nodeConnector); - if (propMap == null) { - return null; - } - - Set props = new HashSet(propMap.values()); - return props; - } - - private boolean isEnabled(NodeConnector nodeConnector) { - if (nodeConnector == null) { - return false; - } - - Config config = (Config) getProp(nodeConnector, Config.ConfigPropName); - State state = (State) getProp(nodeConnector, State.StatePropName); - return ((config != null) && (config.getValue() == Config.ADMIN_UP) - && (state != null) && (state.getValue() == State.EDGE_UP)); - } - - private boolean isTracked(NodeConnector nodeConnector) { - if (readyListHi.contains(nodeConnector)) { - return true; - } - - if (readyListLo.contains(nodeConnector)) { - return true; - } - - if (pendingMap.keySet().contains(nodeConnector)) { - return true; - } - - if (waitingList.contains(nodeConnector)) { - return true; - } - - return false; - } - - private Set getWorkingSet() { - Set workingSet = new HashSet(); - Set removeSet = new HashSet(); - - for (NodeConnector nodeConnector : readyListHi) { - if (isOverLimit(workingSet.size())) { - break; - } - - workingSet.add(nodeConnector); - removeSet.add(nodeConnector); - } - readyListHi.removeAll(removeSet); - - removeSet.clear(); - for (NodeConnector nodeConnector : readyListLo) { - if (isOverLimit(workingSet.size())) { - break; - } - - workingSet.add(nodeConnector); - removeSet.add(nodeConnector); - } - readyListLo.removeAll(removeSet); - - return workingSet; - } - - private Boolean isOverLimit(int size) { - return ((size >= discoveryBatchMaxPorts) && !throttling); - } - - private void addDiscovery() { - Map switches = controller.getSwitches(); - Set sidSet = switches.keySet(); - if (sidSet == null) { - return; - } - for (Long sid : sidSet) { - Node node = NodeCreator.createOFNode(sid); - addDiscovery(node); - } - } - - private void addDiscovery(Node node) { - Map switches = controller.getSwitches(); - ISwitch sw = switches.get((Long) node.getID()); - List ports = sw.getEnabledPorts(); - if (ports == null) { - return; - } - for (OFPhysicalPort port : ports) { - NodeConnector nodeConnector = NodeConnectorCreator - .createOFNodeConnector(port.getPortNumber(), node); - if (!readyListHi.contains(nodeConnector)) { - readyListHi.add(nodeConnector); - } - } - } - - private void addDiscovery(NodeConnector nodeConnector) { - if (isTracked(nodeConnector)) { - return; - } - - readyListHi.add(nodeConnector); - } - - private Set getRemoveSet(Collection c, - Node node) { - Set removeSet = new HashSet(); - if (c == null) { - return removeSet; - } - for (NodeConnector nodeConnector : c) { - if (node.equals(nodeConnector.getNode())) { - removeSet.add(nodeConnector); - } - } - return removeSet; - } - - private void removeDiscovery(Node node) { - Set removeSet; - - removeSet = getRemoveSet(readyListHi, node); - readyListHi.removeAll(removeSet); - - removeSet = getRemoveSet(readyListLo, node); - readyListLo.removeAll(removeSet); - - removeSet = getRemoveSet(waitingList, node); - waitingList.removeAll(removeSet); - - removeSet = getRemoveSet(pendingMap.keySet(), node); - for (NodeConnector nodeConnector : removeSet) { - pendingMap.remove(nodeConnector); - } - - removeSet = getRemoveSet(edgeMap.keySet(), node); - for (NodeConnector nodeConnector : removeSet) { - removeEdge(nodeConnector, false); - } - - removeSet = getRemoveSet(prodMap.keySet(), node); - for (NodeConnector nodeConnector : removeSet) { - removeProdEdge(nodeConnector); - } - } - - private void removeDiscovery(NodeConnector nodeConnector) { - readyListHi.remove(nodeConnector); - readyListLo.remove(nodeConnector); - waitingList.remove(nodeConnector); - pendingMap.remove(nodeConnector); - removeEdge(nodeConnector, false); - removeProdEdge(nodeConnector); - } - - private void checkTimeout() { - Set removeSet = new HashSet(); - Set retrySet = new HashSet(); - int sentCount; - - Set pendingSet = pendingMap.keySet(); - if (pendingSet != null) { - for (NodeConnector nodeConnector : pendingSet) { - sentCount = pendingMap.get(nodeConnector); - pendingMap.put(nodeConnector, ++sentCount); - if (sentCount > getDiscoveryFinalTimeoutInterval()) { - // timeout the edge - removeSet.add(nodeConnector); - logger.trace("Discovery timeout {}", nodeConnector); - } else if (sentCount % discoveryTimeoutTicks == 0) { - retrySet.add(nodeConnector); - } - } - } - - for (NodeConnector nodeConnector : removeSet) { - removeEdge(nodeConnector); - } - - for (NodeConnector nodeConnector : retrySet) { - transmitQ.add(nodeConnector); - } - } - - private void checkAging() { - if (!discoveryAgingEnabled) { - return; - } - - Set removeSet = new HashSet(); - int sentCount; - - Set agingSet = agingMap.keySet(); - if (agingSet != null) { - for (NodeConnector nodeConnector : agingSet) { - sentCount = agingMap.get(nodeConnector); - agingMap.put(nodeConnector, ++sentCount); - if (sentCount > discoveryAgeoutTicks) { - // age out the edge - removeSet.add(nodeConnector); - logger.trace("Discovery age out {}", nodeConnector); - } - } - } - - for (NodeConnector nodeConnector : removeSet) { - removeProdEdge(nodeConnector); - } - } - - private void doDiscovery() { - if (++discoveryTimerTickCount <= discoveryBatchPauseTicks) { - for (NodeConnector nodeConnector : getWorkingSet()) { - pendingMap.put(nodeConnector, 0); - transmitQ.add(nodeConnector); - } - } else if (discoveryTimerTickCount >= discoveryBatchRestartTicks) { - discoveryTimerTickCount = 0; - for (NodeConnector nodeConnector : waitingList) { - if (!readyListLo.contains(nodeConnector)) - readyListLo.add(nodeConnector); - } - waitingList.removeAll(readyListLo); - } - } - - private void doConsistencyCheck() { - if (!discoveryConsistencyCheckEnabled) { - return; - } - - if (++discoveryConsistencyCheckTickCount - % getDiscoveryConsistencyCheckInterval() != 0) { - return; - } - - discoveryConsistencyCheckCallingTimes++; - - Set removeSet = new HashSet(); - Set ncSet = edgeMap.keySet(); - if (ncSet == null) { - return; - } - for (NodeConnector nodeConnector : ncSet) { - if (!isEnabled(nodeConnector)) { - removeSet.add(nodeConnector); - discoveryConsistencyCheckCorrected++; - logger.debug("ConsistencyChecker: remove disabled {}", - nodeConnector); - continue; - } - - if (!isTracked(nodeConnector)) { - waitingList.add(nodeConnector); - discoveryConsistencyCheckCorrected++; - logger.debug("ConsistencyChecker: add back untracked {}", - nodeConnector); - continue; - } - } - - for (NodeConnector nodeConnector : removeSet) { - removeEdge(nodeConnector, false); - } - - // remove stale entries - removeSet.clear(); - for (NodeConnector nodeConnector : waitingList) { - if (!isEnabled(nodeConnector)) { - removeSet.add(nodeConnector); - discoveryConsistencyCheckCorrected++; - logger.debug("ConsistencyChecker: remove disabled {}", - nodeConnector); - } - } - waitingList.removeAll(removeSet); - - // Get a snapshot of all the existing switches - Map switches = this.controller.getSwitches(); - for (ISwitch sw : switches.values()) { - for (OFPhysicalPort port : sw.getEnabledPorts()) { - Node node = NodeCreator.createOFNode(sw.getId()); - NodeConnector nodeConnector = NodeConnectorCreator - .createOFNodeConnector(port.getPortNumber(), node); - if (!isTracked(nodeConnector)) { - waitingList.add(nodeConnector); - discoveryConsistencyCheckCorrected++; - logger.debug("ConsistencyChecker: add back untracked {}", - nodeConnector); - } - } - } - } - - private void addEdge(Edge edge, Set props) { - if (edge == null) { - return; - } - - NodeConnector src = edge.getTailNodeConnector(); - if (!src.getType().equals( - NodeConnector.NodeConnectorIDType.PRODUCTION)) { - pendingMap.remove(src); - if (!waitingList.contains(src)) { - waitingList.add(src); - } - } else { - NodeConnector dst = edge.getHeadNodeConnector(); - agingMap.put(dst, 0); - } - - // notify routeEngine - updateEdge(edge, UpdateType.ADDED, props); - logger.trace("Add edge {}", edge); - } - - - /** - * Update Production Edge - * - * @param edge The Production Edge - * @param props Properties associated with the edge - */ - private void updateProdEdge(Edge edge, Set props) { - NodeConnector edgePort = edge.getHeadNodeConnector(); - - /* Do not update in case there is an existing OpenFlow link */ - if (edgeMap.get(edgePort) != null) { - logger.trace("Discarded edge {} since there is an existing OF link {}", - edge, edgeMap.get(edgePort)); - return; - } - - /* Look for any existing Production Edge */ - Edge oldEdge = prodMap.get(edgePort); - if (oldEdge == null) { - /* Let's add a new one */ - addEdge(edge, props); - } else if (!edge.equals(oldEdge)) { - /* Remove the old one first */ - removeProdEdge(oldEdge.getHeadNodeConnector()); - /* Then add the new one */ - addEdge(edge, props); - } else { - /* o/w, just reset the aging timer */ - NodeConnector dst = edge.getHeadNodeConnector(); - agingMap.put(dst, 0); - } - } - - /** - * Remove Production Edge for a given edge port - * - * @param edgePort The OF edge port - */ - private void removeProdEdge(NodeConnector edgePort) { - agingMap.remove(edgePort); - - Edge edge = null; - Set prodKeySet = prodMap.keySet(); - if ((prodKeySet != null) && (prodKeySet.contains(edgePort))) { - edge = prodMap.get(edgePort); - prodMap.remove(edgePort); - } - - // notify Topology - if (this.discoveryService != null) { - this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null); - } - logger.trace("Remove edge {}", edge); - } - - /* - * Remove OpenFlow edge - */ - private void removeEdge(NodeConnector nodeConnector, boolean stillEnabled) { - pendingMap.remove(nodeConnector); - readyListLo.remove(nodeConnector); - readyListHi.remove(nodeConnector); - - if (stillEnabled) { - // keep discovering - if (!waitingList.contains(nodeConnector)) { - waitingList.add(nodeConnector); - } - } else { - // stop it - waitingList.remove(nodeConnector); - } - - Edge edge = null; - Set edgeKeySet = edgeMap.keySet(); - if ((edgeKeySet != null) && (edgeKeySet.contains(nodeConnector))) { - edge = edgeMap.get(nodeConnector); - edgeMap.remove(nodeConnector); - } - - // notify Topology - if (this.discoveryService != null) { - this.discoveryService.notifyEdge(edge, UpdateType.REMOVED, null); - } - logger.trace("Remove {}", nodeConnector); - } - - private void removeEdge(NodeConnector nodeConnector) { - removeEdge(nodeConnector, isEnabled(nodeConnector)); - } - - private void updateEdge(Edge edge, UpdateType type, Set props) { - if (discoveryService == null) { - return; - } - - this.discoveryService.notifyEdge(edge, type, props); - - NodeConnector src = edge.getTailNodeConnector(), dst = edge - .getHeadNodeConnector(); - if (!src.getType().equals( - NodeConnector.NodeConnectorIDType.PRODUCTION)) { - if (type == UpdateType.ADDED) { - edgeMap.put(src, edge); - } else { - edgeMap.remove(src); - } - } else { - /* - * Save Production edge into different DB keyed by the Edge port - */ - if (type == UpdateType.ADDED) { - prodMap.put(dst, edge); - } else { - prodMap.remove(dst); - } - } - } - - private void moreToReadyListHi(NodeConnector nodeConnector) { - if (readyListLo.contains(nodeConnector)) { - readyListLo.remove(nodeConnector); - readyListHi.add(nodeConnector); - } else if (waitingList.contains(nodeConnector)) { - waitingList.remove(nodeConnector); - readyListHi.add(nodeConnector); - } - } - - private void registerWithOSGIConsole() { - BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()) - .getBundleContext(); - bundleContext.registerService(CommandProvider.class.getName(), this, - null); - } - - private int getDiscoveryConsistencyCheckInterval() { - return discoveryConsistencyCheckMultiple * discoveryBatchRestartTicks; - } - - private int getDiscoveryFinalTimeoutInterval() { - return (discoveryRetry + 1) * discoveryTimeoutTicks; - } - - @Override - public String getHelp() { - StringBuffer help = new StringBuffer(); - help.append("---Topology Discovery---\n"); - help.append("\t prlh - Print readyListHi entries\n"); - help.append("\t prll - Print readyListLo entries\n"); - help.append("\t pwl - Print waitingList entries\n"); - help.append("\t ppl - Print pendingList entries\n"); - help.append("\t ptick - Print tick time in msec\n"); - help.append("\t pcc - Print CC info\n"); - help.append("\t psize - Print sizes of all the lists\n"); - help.append("\t ptm - Print timeout info\n"); - help.append("\t ecc - Enable CC\n"); - help.append("\t dcc - Disable CC\n"); - help.append("\t scc [multiple] - Set/show CC multiple and interval\n"); - help.append("\t sports [ports] - Set/show max ports per batch\n"); - help.append("\t spause [ticks] - Set/show pause period\n"); - help.append("\t sdi [ticks] - Set/show discovery interval in ticks\n"); - help.append("\t stm [ticks] - Set/show per timeout ticks\n"); - help.append("\t sretry [count] - Set/show num of retries\n"); - help.append("\t addsw - Add a switch\n"); - help.append("\t remsw - Remove a switch\n"); - help.append("\t page - Print aging info\n"); - help.append("\t sage - Set/Show aging time limit\n"); - help.append("\t eage - Enable aging\n"); - help.append("\t dage - Disable aging\n"); - help.append("\t pthrot - Print throttling\n"); - help.append("\t ethrot - Enable throttling\n"); - help.append("\t dthrot - Disable throttling\n"); - return help.toString(); - } - - public void _prlh(CommandInterpreter ci) { - ci.println("ReadyListHi\n"); - for (NodeConnector nodeConnector : readyListHi) { - if (nodeConnector == null) { - continue; - } - ci.println(nodeConnector); - } - } - - public void _prll(CommandInterpreter ci) { - ci.println("ReadyListLo\n"); - for (NodeConnector nodeConnector : readyListLo) { - if (nodeConnector == null) { - continue; - } - ci.println(nodeConnector); - } - } - - public void _pwl(CommandInterpreter ci) { - ci.println("WaitingList\n"); - for (NodeConnector nodeConnector : waitingList) { - if (nodeConnector == null) { - continue; - } - ci.println(nodeConnector); - } - } - - public void _ppl(CommandInterpreter ci) { - ci.println("PendingList\n"); - for (NodeConnector nodeConnector : pendingMap.keySet()) { - if (nodeConnector == null) { - continue; - } - ci.println(nodeConnector); - } - } - - public void _ptick(CommandInterpreter ci) { - ci.println("Current timer is " + discoveryTimerTick + " msec per tick"); - } - - public void _pcc(CommandInterpreter ci) { - if (discoveryConsistencyCheckEnabled) { - ci.println("ConsistencyChecker is currently enabled"); - } else { - ci.println("ConsistencyChecker is currently disabled"); - } - ci.println("Interval " + getDiscoveryConsistencyCheckInterval()); - ci.println("Multiple " + discoveryConsistencyCheckMultiple); - ci.println("Number of times called " - + discoveryConsistencyCheckCallingTimes); - ci.println("Corrected count " + discoveryConsistencyCheckCorrected); - } - - public void _ptm(CommandInterpreter ci) { - ci.println("Final timeout ticks " + getDiscoveryFinalTimeoutInterval()); - ci.println("Per timeout ticks " + discoveryTimeoutTicks); - ci.println("Retry after initial timeout " + discoveryRetry); - } - - public void _psize(CommandInterpreter ci) { - ci.println("readyListLo size " + readyListLo.size() + "\n" - + "readyListHi size " + readyListHi.size() + "\n" - + "waitingList size " + waitingList.size() + "\n" - + "pendingMap size " + pendingMap.size() + "\n" - + "edgeMap size " + edgeMap.size() + "\n" + "prodMap size " - + prodMap.size() + "\n" + "agingMap size " + agingMap.size()); - } - - public void _page(CommandInterpreter ci) { - if (this.discoveryAgingEnabled) { - ci.println("Aging is enabled"); - } else { - ci.println("Aging is disabled"); - } - ci.println("Current aging time limit " + this.discoveryAgeoutTicks); - ci.println("\n"); - ci.println(" Edge Aging "); - Collection prodSet = prodMap.values(); - if (prodSet == null) { - return; - } - for (Edge edge : prodSet) { - Integer aging = agingMap.get(edge.getHeadNodeConnector()); - if (aging != null) { - ci.println(edge + " " + aging); - } - } - ci.println("\n"); - ci.println(" NodeConnector Edge "); - Set keySet = prodMap.keySet(); - if (keySet == null) { - return; - } - for (NodeConnector nc : keySet) { - ci.println(nc + " " + prodMap.get(nc)); - } - return; - } - - public void _sage(CommandInterpreter ci) { - String val = ci.nextArgument(); - if (val == null) { - ci.println("Please enter aging time limit. Current value " - + this.discoveryAgeoutTicks); - return; - } - try { - this.discoveryAgeoutTicks = Integer.parseInt(val); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _eage(CommandInterpreter ci) { - this.discoveryAgingEnabled = true; - ci.println("Aging is enabled"); - return; - } - - public void _dage(CommandInterpreter ci) { - this.discoveryAgingEnabled = false; - ci.println("Aging is disabled"); - return; - } - - public void _scc(CommandInterpreter ci) { - String val = ci.nextArgument(); - if (val == null) { - ci.println("Please enter CC multiple. Current multiple " - + discoveryConsistencyCheckMultiple + " (interval " - + getDiscoveryConsistencyCheckInterval() - + ") calling times " - + discoveryConsistencyCheckCallingTimes); - return; - } - try { - discoveryConsistencyCheckMultiple = Integer.parseInt(val); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _ecc(CommandInterpreter ci) { - this.discoveryConsistencyCheckEnabled = true; - ci.println("ConsistencyChecker is enabled"); - return; - } - - public void _dcc(CommandInterpreter ci) { - this.discoveryConsistencyCheckEnabled = false; - ci.println("ConsistencyChecker is disabled"); - return; - } - - public void _pspf(CommandInterpreter ci) { - if (this.discoverySpoofingEnabled) { - ci.println("Discovery spoofing is enabled"); - } else { - ci.println("Discovery spoofing is disabled"); - } - return; - } - - public void _espf(CommandInterpreter ci) { - this.discoverySpoofingEnabled = true; - ci.println("Discovery spoofing is enabled"); - return; - } - - public void _dspf(CommandInterpreter ci) { - this.discoverySpoofingEnabled = false; - ci.println("Discovery spoofing is disabled"); - return; - } - - public void _spause(CommandInterpreter ci) { - String val = ci.nextArgument(); - String out = "Please enter pause period less than " - + discoveryBatchRestartTicks + ". Current pause period is " - + discoveryBatchPausePeriod + " pause tick is " - + discoveryBatchPauseTicks + "."; - - if (val != null) { - try { - int pause = Integer.parseInt(val); - if (pause < discoveryBatchRestartTicks) { - discoveryBatchPausePeriod = pause; - discoveryBatchPauseTicks = discoveryBatchRestartTicks - discoveryBatchPausePeriod; - return; - } - } catch (Exception e) { - } - } - - ci.println(out); - } - - public void _sdi(CommandInterpreter ci) { - String val = ci.nextArgument(); - String out = "Please enter discovery interval greater than " - + discoveryBatchPausePeriod + ". Current value is " - + discoveryBatchRestartTicks + "."; - - if (val != null) { - try { - int restart = Integer.parseInt(val); - if (restart > discoveryBatchPausePeriod) { - discoveryBatchRestartTicks = restart; - discoveryBatchPauseTicks = discoveryBatchRestartTicks - discoveryBatchPausePeriod; - return; - } - } catch (Exception e) { - } - } - ci.println(out); - } - - public void _sports(CommandInterpreter ci) { - String val = ci.nextArgument(); - if (val == null) { - ci.println("Please enter max ports per batch. Current value is " - + discoveryBatchMaxPorts); - return; - } - try { - discoveryBatchMaxPorts = Integer.parseInt(val); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _sretry(CommandInterpreter ci) { - String val = ci.nextArgument(); - if (val == null) { - ci.println("Please enter number of retries. Current value is " - + discoveryRetry); - return; - } - try { - discoveryRetry = Integer.parseInt(val); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _stm(CommandInterpreter ci) { - String val = ci.nextArgument(); - String out = "Please enter timeout tick value less than " - + discoveryBatchRestartTicks + ". Current value is " - + discoveryTimeoutTicks; - if (val != null) { - try { - int timeout = Integer.parseInt(val); - if (timeout < discoveryBatchRestartTicks) { - discoveryTimeoutTicks = timeout; - return; - } - } catch (Exception e) { - } - } - - ci.println(out); - } - - public void _addsw(CommandInterpreter ci) { - String val = ci.nextArgument(); - Long sid; - try { - sid = Long.parseLong(val); - Node node = NodeCreator.createOFNode(sid); - addDiscovery(node); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _remsw(CommandInterpreter ci) { - String val = ci.nextArgument(); - Long sid; - try { - sid = Long.parseLong(val); - Node node = NodeCreator.createOFNode(sid); - removeDiscovery(node); - } catch (Exception e) { - ci.println("Please enter a valid number"); - } - return; - } - - public void _pthrot(CommandInterpreter ci) { - if (this.throttling) { - ci.println("Throttling is enabled"); - } else { - ci.println("Throttling is disabled"); - } - } - - public void _ethrot(CommandInterpreter ci) { - this.throttling = true; - ci.println("Throttling is enabled"); - return; - } - - public void _dthrot(CommandInterpreter ci) { - this.throttling = false; - ci.println("Throttling is disabled"); - return; - } - - @Override - public void updateNode(Node node, UpdateType type, Set props) { - switch (type) { - case ADDED: - addNode(node, props); - break; - case REMOVED: - removeNode(node); - break; - default: - break; - } - } - - @Override - public void updateNodeConnector(NodeConnector nodeConnector, - UpdateType type, Set props) { - Config config = null; - State state = null; - boolean enabled = false; - - for (Property prop : props) { - if (prop.getName().equals(Config.ConfigPropName)) { - config = (Config) prop; - } else if (prop.getName().equals(State.StatePropName)) { - state = (State) prop; - } - } - enabled = ((config != null) && (config.getValue() == Config.ADMIN_UP) - && (state != null) && (state.getValue() == State.EDGE_UP)); - - switch (type) { - case ADDED: - if (enabled) { - addDiscovery(nodeConnector); - logger.trace("ADDED enabled {}", nodeConnector); - } else { - logger.trace("ADDED disabled {}", nodeConnector); - } - break; - case CHANGED: - if (enabled) { - addDiscovery(nodeConnector); - logger.trace("CHANGED enabled {}", nodeConnector); - } else { - removeDiscovery(nodeConnector); - logger.trace("CHANGED disabled {}", nodeConnector); - } - break; - case REMOVED: - removeDiscovery(nodeConnector); - logger.trace("REMOVED enabled {}", nodeConnector); - break; - default: - return; - } - } - - public void addNode(Node node, Set props) { - if (node == null) - return; - - addDiscovery(node); - } - - public void removeNode(Node node) { - if (node == null) - return; - - removeDiscovery(node); - } - - public void updateNode(Node node, Set props) { - } - - void setController(IController s) { - this.controller = s; - } - - void unsetController(IController s) { - if (this.controller == s) { - this.controller = null; - } - } - - public void setPluginInInventoryService(IPluginInInventoryService service) { - this.pluginInInventoryService = service; - } - - public void unsetPluginInInventoryService(IPluginInInventoryService service) { - this.pluginInInventoryService = null; - } - - public void setIDataPacketMux(IDataPacketMux service) { - this.iDataPacketMux = service; - } - - public void unsetIDataPacketMux(IDataPacketMux service) { - if (this.iDataPacketMux == service) { - this.iDataPacketMux = null; - } - } - - void setDiscoveryService(IDiscoveryService s) { - this.discoveryService = s; - } - - void unsetDiscoveryService(IDiscoveryService s) { - if (this.discoveryService == s) { - this.discoveryService = null; - } - } - - private void initDiscoveryPacket() { - // Create LLDP ChassisID TLV - chassisIdTlv = new LLDPTLV(); - chassisIdTlv.setType((byte) LLDPTLV.TLVType.ChassisID.getValue()); - - // Create LLDP PortID TLV - portIdTlv = new LLDPTLV(); - portIdTlv.setType((byte) LLDPTLV.TLVType.PortID.getValue()); - - // Create LLDP TTL TLV - byte[] ttl = new byte[] {(byte) 0, (byte) 120 }; - ttlTlv = new LLDPTLV(); - ttlTlv.setType((byte) LLDPTLV.TLVType.TTL.getValue()).setLength( - (short) ttl.length).setValue(ttl); - - customTlv = new LLDPTLV(); - } - - /** - * Function called by the dependency manager when all the required - * dependencies are satisfied - * - */ - void init() { - logger.trace("Init called"); - - transmitQ = new LinkedBlockingQueue(); - - readyListHi = new CopyOnWriteArrayList(); - readyListLo = new CopyOnWriteArrayList(); - waitingList = new CopyOnWriteArrayList(); - pendingMap = new ConcurrentHashMap(); - edgeMap = new ConcurrentHashMap(); - agingMap = new ConcurrentHashMap(); - prodMap = new ConcurrentHashMap(); - - discoveryTimer = new Timer("DiscoveryService"); - discoveryTimerTask = new DiscoveryTimerTask(); - - transmitThread = new Thread(new DiscoveryTransmit(transmitQ)); - - initDiscoveryPacket(); - - registerWithOSGIConsole(); - } - - /** - * Function called by the dependency manager when at least one dependency - * become unsatisfied or when the component is shutting down because for - * example bundle is being stopped. - * - */ - void destroy() { - transmitQ = null; - readyListHi = null; - readyListLo = null; - waitingList = null; - pendingMap = null; - edgeMap = null; - agingMap = null; - prodMap = null; - discoveryTimer = null; - discoveryTimerTask = null; - transmitThread = null; - } - - /** - * Function called by dependency manager after "init ()" is called and after - * the services provided by the class are registered in the service registry - * - */ - void start() { - discoveryTimer.schedule(discoveryTimerTask, discoveryTimerTick, - discoveryTimerTick); - transmitThread.start(); - } - - /** - * Function called after registering the - * service in OSGi service registry. - */ - void started() { - /* get a snapshot of all the existing switches */ - addDiscovery(); - } - - /** - * Function called by the dependency manager before the services exported by - * the component are unregistered, this will be followed by a "destroy ()" - * calls - * - */ - void stop() { - shuttingDown = true; - discoveryTimer.cancel(); - transmitThread.interrupt(); - } - - @Override - public void tagUpdated(String containerName, Node n, short oldTag, - short newTag, UpdateType t) { - } - - @Override - public void containerFlowUpdated(String containerName, - ContainerFlow previousFlow, ContainerFlow currentFlow, UpdateType t) { - } - - @Override - public void nodeConnectorUpdated(String containerName, NodeConnector p, - UpdateType t) { - switch (t) { - case ADDED: - moreToReadyListHi(p); - break; - default: - break; - } - } - - @Override - public void containerModeUpdated(UpdateType t) { - // do nothing - } - - private byte[] getSouceMACFromNodeID(String nodeId) { - byte[] cid = HexEncode.bytesFromHexString(nodeId); - byte[] sourceMac = new byte[6]; - int pos = cid.length - sourceMac.length; - - if (pos >= 0) { - System.arraycopy(cid, pos, sourceMac, 0, sourceMac.length); - } - - return sourceMac; - } - - /** - * This method returns the interval which determines how often the discovery - * packets will be sent. Default is 300 seconds. - * - * @return The discovery interval in second - */ - private static int getDiscoveryInterval() { - String elapsedTime = System.getProperty("of.discoveryInterval"); - int rv = 300; - - try { - if (elapsedTime != null) { - rv = Integer.parseInt(elapsedTime); - } - } catch (Exception e) { - } - - return rv; - } - - /** - * This method returns the timeout value in waiting for response of a - * discovery query. Default is 60 seconds. - * - * @return The discovery timeout in second - */ - private static int getDiscoveryTimeout() { - String elapsedTime = System.getProperty("of.discoveryTimeout"); - int rv = 60; - - try { - if (elapsedTime != null) { - rv = Integer.parseInt(elapsedTime); - } - } catch (Exception e) { - } - - return rv; - } -}