2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.controller.hosttracker.internal;
11 import java.net.InetAddress;
12 import java.net.UnknownHostException;
13 import java.util.ArrayList;
14 import java.util.Collections;
15 import java.util.Dictionary;
16 import java.util.EnumSet;
17 import java.util.HashSet;
18 import java.util.List;
20 import java.util.Map.Entry;
22 import java.util.Timer;
23 import java.util.TimerTask;
24 import java.util.concurrent.Callable;
25 import java.util.concurrent.ConcurrentHashMap;
26 import java.util.concurrent.ConcurrentMap;
27 import java.util.concurrent.ExecutorService;
28 import java.util.concurrent.Executors;
29 import java.util.concurrent.Future;
31 import org.apache.felix.dm.Component;
32 import org.opendaylight.controller.clustering.services.CacheConfigException;
33 import org.opendaylight.controller.clustering.services.CacheExistException;
34 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
35 import org.opendaylight.controller.clustering.services.IClusterServices;
36 import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
37 import org.opendaylight.controller.hosttracker.hostAware.IHostFinder;
38 import org.opendaylight.controller.hosttracker.IfHostListener;
39 import org.opendaylight.controller.hosttracker.IfIptoHost;
40 import org.opendaylight.controller.hosttracker.IfNewHostNotify;
41 import org.opendaylight.controller.sal.core.ConstructionException;
42 import org.opendaylight.controller.sal.core.Edge;
43 import org.opendaylight.controller.sal.core.Host;
44 import org.opendaylight.controller.sal.core.Node;
45 import org.opendaylight.controller.sal.core.NodeConnector;
46 import org.opendaylight.controller.sal.core.Property;
47 import org.opendaylight.controller.sal.core.State;
48 import org.opendaylight.controller.sal.core.Tier;
49 import org.opendaylight.controller.sal.core.UpdateType;
50 import org.opendaylight.controller.sal.packet.address.DataLinkAddress;
51 import org.opendaylight.controller.sal.packet.address.EthernetAddress;
52 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
53 import org.opendaylight.controller.sal.utils.GlobalConstants;
54 import org.opendaylight.controller.sal.utils.HexEncode;
55 import org.opendaylight.controller.sal.utils.NodeCreator;
56 import org.opendaylight.controller.sal.utils.Status;
57 import org.opendaylight.controller.sal.utils.StatusCode;
58 import org.opendaylight.controller.switchmanager.IInventoryListener;
59 import org.opendaylight.controller.switchmanager.ISwitchManager;
60 import org.opendaylight.controller.switchmanager.ISwitchManagerAware;
61 import org.opendaylight.controller.switchmanager.Subnet;
62 import org.opendaylight.controller.topologymanager.ITopologyManager;
63 import org.opendaylight.controller.topologymanager.ITopologyManagerAware;
64 import org.slf4j.Logger;
65 import org.slf4j.LoggerFactory;
68 * @file HostTracker.java This class tracks the location of IP Hosts as to which
69 * Switch, Port, VLAN, they are connected to, as well as their MAC
70 * address. This is done dynamically as well as statically. The dynamic
71 * mechanism consists of listening to ARP messages as well sending ARP
72 * requests. Static mechanism consists of Northbound APIs to add or remove
73 * the hosts from the local database. ARP aging is also implemented to age
74 * out dynamically learned hosts. Interface methods are provided for other
75 * applications to 1. Query the local database for a single host 2. Get a
76 * list of all hosts 3. Get notification if a host is learned/added or
77 * removed the database
80 public class HostTracker implements IfIptoHost, IfHostListener,
81 ISwitchManagerAware, IInventoryListener, ITopologyManagerAware {
82 private static final Logger logger = LoggerFactory
83 .getLogger(HostTracker.class);
84 private IHostFinder hostFinder;
85 private ConcurrentMap<InetAddress, HostNodeConnector> hostsDB;
87 * Following is a list of hosts which have been requested by NB APIs to be
88 * added, but either the switch or the port is not sup, so they will be
89 * added here until both come up
91 private ConcurrentMap<NodeConnector, HostNodeConnector> inactiveStaticHosts;
92 private Set<IfNewHostNotify> newHostNotify = Collections
93 .synchronizedSet(new HashSet<IfNewHostNotify>());
95 private ITopologyManager topologyManager;
96 private IClusterContainerServices clusterContainerService = null;
97 private ISwitchManager switchManager = null;
99 private Timer arp_refresh_timer;
100 private String containerName = null;
102 private static class ARPPending {
103 protected InetAddress hostIP;
104 protected short sent_count;
105 protected HostTrackerCallable hostTrackerCallable;
107 public InetAddress getHostIP() {
111 public short getSent_count() {
115 public HostTrackerCallable getHostTrackerCallable() {
116 return hostTrackerCallable;
119 public void setHostIP(InetAddress networkAddr) {
120 this.hostIP = networkAddr;
123 public void setSent_count(short count) {
124 this.sent_count = count;
127 public void setHostTrackerCallable(HostTrackerCallable callable) {
128 hostTrackerCallable = callable;
132 // This list contains the hosts for which ARP requests are being sent
134 private List<ARPPending> ARPPendingList = new ArrayList<HostTracker.ARPPending>();
136 * This list below contains the hosts which were initially in ARPPendingList
137 * above, but ARP response didn't come from there hosts after multiple
138 * attempts over 8 seconds. The assumption is that the response didn't come
139 * back due to one of the following possibilities: 1. The L3 interface
140 * wasn't created for this host in the controller. This would cause
141 * arphandler not to know where to send the ARP 2. The host facing port is
142 * down 3. The IP host doesn't exist or is not responding to ARP requests
144 * Conditions 1 and 2 above can be recovered if ARP is sent when the
145 * relevant L3 interface is added or the port facing host comes up. Whenever
146 * L3 interface is added or host facing port comes up, ARP will be sent to
147 * hosts in this list.
149 * We can't recover from condition 3 above
151 private ArrayList<ARPPending> failedARPReqList = new ArrayList<HostTracker.ARPPending>();
153 public HostTracker() {
156 private void startUp() {
161 timer.schedule(new OutStandingARPHandler(), 4000, 4000);
163 /* ARP Refresh Timer to go off every 5 seconds to implement ARP aging */
164 arp_refresh_timer = new Timer();
165 arp_refresh_timer.schedule(new ARPRefreshHandler(), 5000, 5000);
166 logger.debug("startUp: Caches created, timers started");
169 @SuppressWarnings("deprecation")
170 private void allocateCache() {
171 if (this.clusterContainerService == null) {
172 logger.error("un-initialized clusterContainerService, can't create cache");
175 logger.debug("Creating Cache for HostTracker");
177 this.clusterContainerService.createCache("hostTrackerAH",
178 EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
179 this.clusterContainerService.createCache("hostTrackerIH",
180 EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
181 } catch (CacheConfigException cce) {
182 logger.error("Cache couldn't be created for HostTracker - check cache mode");
183 } catch (CacheExistException cce) {
184 logger.error("Cache for HostTracker already exists, destroy and recreate");
186 logger.debug("Cache successfully created for HostTracker");
189 @SuppressWarnings({ "unchecked", "deprecation" })
190 private void retrieveCache() {
191 if (this.clusterContainerService == null) {
192 logger.error("un-initialized clusterContainerService, can't retrieve cache");
195 logger.debug("Retrieving cache for HostTrackerAH");
196 hostsDB = (ConcurrentMap<InetAddress, HostNodeConnector>) this.clusterContainerService
197 .getCache("hostTrackerAH");
198 if (hostsDB == null) {
199 logger.error("Cache couldn't be retrieved for HostTracker");
201 logger.debug("Cache was successfully retrieved for HostTracker");
202 logger.debug("Retrieving cache for HostTrackerIH");
203 inactiveStaticHosts = (ConcurrentMap<NodeConnector, HostNodeConnector>) this.clusterContainerService
204 .getCache("hostTrackerIH");
205 if (inactiveStaticHosts == null) {
206 logger.error("Cache couldn't be retrieved for HostTrackerIH");
208 logger.debug("Cache was successfully retrieved for HostTrackerIH");
211 public void nonClusterObjectCreate() {
212 hostsDB = new ConcurrentHashMap<InetAddress, HostNodeConnector>();
213 inactiveStaticHosts = new ConcurrentHashMap<NodeConnector, HostNodeConnector>();
216 @SuppressWarnings("deprecation")
217 private void destroyCache() {
218 if (this.clusterContainerService == null) {
219 logger.error("un-initialized clusterMger, can't destroy cache");
222 logger.debug("Destroying Cache for HostTracker");
223 this.clusterContainerService.destroyCache("hostTrackerAH");
224 this.clusterContainerService.destroyCache("hostTrackerIH");
225 nonClusterObjectCreate();
228 public void shutDown() {
231 public void setnewHostNotify(IfNewHostNotify obj) {
232 this.newHostNotify.add(obj);
235 public void unsetnewHostNotify(IfNewHostNotify obj) {
236 this.newHostNotify.remove(obj);
239 public void setArpHandler(IHostFinder hostFinder) {
240 this.hostFinder = hostFinder;
243 public void unsetArpHandler(IHostFinder hostFinder) {
244 if (this.hostFinder == hostFinder) {
245 logger.debug("Arp Handler Service removed!");
246 this.hostFinder = null;
250 public void setTopologyManager(ITopologyManager s) {
251 this.topologyManager = s;
254 public void unsetTopologyManager(ITopologyManager s) {
255 if (this.topologyManager == s) {
256 logger.debug("Topology Manager Service removed!");
257 this.topologyManager = null;
261 private boolean hostExists(HostNodeConnector host) {
262 HostNodeConnector lhost = hostsDB.get(host.getNetworkAddress());
263 return host.equals(lhost);
266 private HostNodeConnector getHostFromOnActiveDB(InetAddress networkAddress) {
267 return hostsDB.get(networkAddress);
270 private Entry<NodeConnector, HostNodeConnector> getHostFromInactiveDB(
271 InetAddress networkAddress) {
272 for (Entry<NodeConnector, HostNodeConnector> entry : inactiveStaticHosts
274 if (entry.getValue().equalsByIP(networkAddress)) {
276 "getHostFromInactiveDB(): Inactive Host found for IP:{} ",
277 networkAddress.getHostAddress());
282 "getHostFromInactiveDB() Inactive Host Not found for IP: {}",
283 networkAddress.getHostAddress());
287 private void removeHostFromInactiveDB(InetAddress networkAddress) {
288 NodeConnector nodeConnector = null;
289 for (Entry<NodeConnector, HostNodeConnector> entry : inactiveStaticHosts
291 if (entry.getValue().equalsByIP(networkAddress)) {
292 nodeConnector = entry.getKey();
296 if (nodeConnector != null) {
297 inactiveStaticHosts.remove(nodeConnector);
298 logger.debug("removeHostFromInactiveDB(): Host Removed for IP: {}",
299 networkAddress.getHostAddress());
302 logger.debug("removeHostFromInactiveDB(): Host Not found for IP: {}",
303 networkAddress.getHostAddress());
306 protected boolean hostMoved(HostNodeConnector host) {
307 if (hostQuery(host.getNetworkAddress()) != null) {
313 public HostNodeConnector hostQuery(InetAddress networkAddress) {
314 return hostsDB.get(networkAddress);
317 public Future<HostNodeConnector> discoverHost(InetAddress networkAddress) {
318 ExecutorService executor = Executors.newFixedThreadPool(1);
319 if (executor == null) {
320 logger.error("discoverHost: Null executor");
323 Callable<HostNodeConnector> worker = new HostTrackerCallable(this,
325 Future<HostNodeConnector> submit = executor.submit(worker);
329 public HostNodeConnector hostFind(InetAddress networkAddress) {
331 * Sometimes at boot with containers configured in the startup we hit
332 * this path (from TIF) when hostFinder has not been set yet Caller
333 * already handles the null return
336 if (hostFinder == null) {
337 logger.debug("Exiting hostFind, null hostFinder");
341 HostNodeConnector host = hostQuery(networkAddress);
343 logger.debug("hostFind(): Host found for IP: {}",
344 networkAddress.getHostAddress());
347 /* host is not found, initiate a discovery */
348 hostFinder.find(networkAddress);
349 /* Also add this host to ARPPending List for any potential retries */
350 AddtoARPPendingList(networkAddress);
352 "hostFind(): Host Not Found for IP: {}, Inititated Host Discovery ...",
353 networkAddress.getHostAddress());
357 public Set<HostNodeConnector> getAllHosts() {
358 Set<HostNodeConnector> allHosts = new HashSet<HostNodeConnector>();
359 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
360 HostNodeConnector host = entry.getValue();
363 logger.debug("Exiting getAllHosts, Found {} Hosts", allHosts.size());
368 public Set<HostNodeConnector> getActiveStaticHosts() {
369 Set<HostNodeConnector> list = new HashSet<HostNodeConnector>();
370 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
371 HostNodeConnector host = entry.getValue();
372 if (host.isStaticHost()) {
376 logger.debug("getActiveStaticHosts(): Found {} Hosts", list.size());
381 public Set<HostNodeConnector> getInactiveStaticHosts() {
382 Set<HostNodeConnector> list = new HashSet<HostNodeConnector>();
383 for (Entry<NodeConnector, HostNodeConnector> entry : inactiveStaticHosts
385 list.add(entry.getValue());
387 logger.debug("getInactiveStaticHosts(): Found {} Hosts", list.size());
391 private void AddtoARPPendingList(InetAddress networkAddr) {
392 ARPPending arphost = new ARPPending();
394 arphost.setHostIP(networkAddr);
395 arphost.setSent_count((short) 1);
396 ARPPendingList.add(arphost);
397 logger.debug("Host Added to ARPPending List, IP: {}",
398 networkAddr.toString());
401 private void removePendingARPFromList(int index) {
402 if (index >= ARPPendingList.size()) {
404 "removePendingARPFromList(): index greater than the List. Size:{}, Index:{}",
405 ARPPendingList.size(), index);
408 ARPPending arphost = ARPPendingList.remove(index);
409 HostTrackerCallable htCallable = arphost.getHostTrackerCallable();
410 if (htCallable != null)
414 public void setCallableOnPendingARP(InetAddress networkAddr,
415 HostTrackerCallable callable) {
417 for (int i = 0; i < ARPPendingList.size(); i++) {
418 arphost = ARPPendingList.get(i);
419 if (arphost.getHostIP().equals(networkAddr)) {
420 arphost.setHostTrackerCallable(callable);
425 private void ProcPendingARPReqs(InetAddress networkAddr) {
428 for (int i = 0; i < ARPPendingList.size(); i++) {
429 arphost = ARPPendingList.get(i);
430 if (arphost.getHostIP().equals(networkAddr)) {
432 * An ARP was sent for this host. The address is learned, remove
435 removePendingARPFromList(i);
436 logger.debug("Host Removed from ARPPending List, IP: {}",
437 networkAddr.toString());
443 * It could have been a host from the FailedARPReqList
446 for (int i = 0; i < failedARPReqList.size(); i++) {
447 arphost = failedARPReqList.get(i);
448 if (arphost.getHostIP().equals(networkAddr)) {
450 * An ARP was sent for this host. The address is learned, remove
453 failedARPReqList.remove(i);
454 logger.debug("Host Removed from FailedARPReqList List, IP: {}",
455 networkAddr.toString());
462 private void learnNewHost(HostNodeConnector host) {
463 host.initArpSendCountDown();
464 hostsDB.put(host.getNetworkAddress(), host);
465 logger.debug("New Host Learned: MAC: {} IP: {}",
466 HexEncode.bytesToHexString(host.getDataLayerAddressBytes()),
467 host.getNetworkAddress().getHostAddress());
471 private void removeKnownHost(InetAddress key) {
472 HostNodeConnector host = hostsDB.get(key);
474 logger.debug("Removing Host: IP:{}", host.getNetworkAddress()
479 "removeKnownHost(): Host for IP address {} not found in hostsDB",
480 key.getHostAddress());
484 private class NotifyHostThread extends Thread {
486 private HostNodeConnector host;
488 public NotifyHostThread(HostNodeConnector h) {
493 /* Check for Host Move case */
494 if (hostMoved(host)) {
496 * Host has been moved from one location (switch,port, MAC, or
497 * VLAN). Remove the existing host with its previous location
498 * parameters, inform the applications, and add it as a new Host
500 HostNodeConnector removedHost = hostsDB.get(host
501 .getNetworkAddress());
502 removeKnownHost(host.getNetworkAddress());
503 if (removedHost != null) {
504 notifyHostLearnedOrRemoved(removedHost, false);
506 "Host move occurred. Old Host:{}, New Host: {}",
510 "Host to be removed not found in hostsDB. Host {}",
515 /* check if there is an outstanding request for this host */
516 InetAddress networkAddr = host.getNetworkAddress();
520 ProcPendingARPReqs(networkAddr);
521 notifyHostLearnedOrRemoved(host, true);
525 public void hostListener(HostNodeConnector host) {
527 if (hostExists(host)) {
528 logger.debug("ARP received for Host: {}", host);
529 HostNodeConnector existinghost = hostsDB.get(host
530 .getNetworkAddress());
531 existinghost.initArpSendCountDown();
534 new NotifyHostThread(host).start();
537 // Notify whoever is interested that a new host was learned (dynamically or
539 private void notifyHostLearnedOrRemoved(HostNodeConnector host, boolean add) {
540 // Update listeners if any
541 if (newHostNotify != null) {
542 synchronized (this.newHostNotify) {
543 for (IfNewHostNotify ta : newHostNotify) {
546 ta.notifyHTClient(host);
548 ta.notifyHTClientHostRemoved(host);
550 } catch (Exception e) {
551 logger.error("Exception on callback", e);
556 logger.error("notifyHostLearnedOrRemoved(): New host notify is null");
559 // Topology update is for some reason outside of listeners registry
561 Node node = host.getnodeconnectorNode();
563 NodeConnector p = host.getnodeConnector();
565 DataLinkAddress dla = new EthernetAddress(
566 host.getDataLayerAddressBytes());
567 h = new org.opendaylight.controller.sal.core.Host(dla,
568 host.getNetworkAddress());
569 } catch (ConstructionException ce) {
574 if (topologyManager != null && p != null && h != null) {
576 Tier tier = new Tier(1);
577 switchManager.setNodeProp(node, tier);
578 topologyManager.updateHostLink(p, h, UpdateType.ADDED, null);
580 * This is a temporary fix for Cisco Live's Hadoop
581 * Demonstration. The concept of Tiering must be revisited based
582 * on other application requirements and the design might
583 * warrant a separate module (as it involves tracking the
584 * topology/ host changes & updating the Tiering numbers in an
587 updateSwitchTiers(node, 1);
590 * The following 2 lines are added for testing purposes. We can
591 * remove it once the North-Bound APIs are available for
594 * ArrayList<ArrayList<String>> hierarchies =
595 * getHostNetworkHierarchy(host.getNetworkAddress());
596 * logHierarchies(hierarchies);
599 // No need to reset the tiering if no other hosts are currently
601 // If this switch was discovered to be an access switch, it
602 // still is even if the host is down
603 Tier tier = new Tier(0);
604 switchManager.setNodeProp(node, tier);
605 topologyManager.updateHostLink(p, h, UpdateType.REMOVED, null);
611 * When a new Host is learnt by the hosttracker module, it places the
612 * directly connected Node in Tier-1 & using this function, updates the Tier
613 * value for all other Nodes in the network hierarchy.
615 * This is a recursive function and it takes care of updating the Tier value
616 * for all the connected and eligible Nodes.
619 * Node that represents one of the Vertex in the Topology Graph.
621 * The Tier on which n belongs
623 private void updateSwitchTiers(Node n, int currentTier) {
624 Map<Node, Set<Edge>> ndlinks = topologyManager.getNodeEdges();
625 if (ndlinks == null) {
627 "updateSwitchTiers(): ndlinks null for Node: {}, Tier:{}",
631 Set<Edge> links = ndlinks.get(n);
633 logger.debug("updateSwitchTiers(): links null for ndlinks:{}",
637 ArrayList<Node> needsVisiting = new ArrayList<Node>();
638 for (Edge lt : links) {
639 if (!lt.getHeadNodeConnector().getType()
640 .equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
641 // We don't want to work on Node that are not openflow
645 Node dstNode = lt.getHeadNodeConnector().getNode();
646 if (switchNeedsTieringUpdate(dstNode, currentTier + 1)) {
647 Tier t = new Tier(currentTier + 1);
648 switchManager.setNodeProp(dstNode, t);
649 needsVisiting.add(dstNode);
654 * Due to the nature of the problem, having a separate loop for nodes
655 * that needs visiting provides a decent walk optimization.
657 for (Node node : needsVisiting) {
658 updateSwitchTiers(node, currentTier + 1);
663 * Internal convenience routine to check the eligibility of a Switch for a
664 * Tier update. Any Node with Tier=0 or a Tier value that is greater than
665 * the new Tier Value is eligible for the update.
668 * Node for which the Tier update eligibility is checked
671 * @return <code>true</code> if the Node is eligible for Tier Update
672 * <code>false</code> otherwise
675 private boolean switchNeedsTieringUpdate(Node n, int tier) {
677 logger.error("switchNeedsTieringUpdate(): Null node for tier: {}",
682 * Node could have gone down
684 if (!switchManager.getNodes().contains(n)) {
687 // This is the case where Tier was never set for this node
688 Tier t = (Tier) switchManager.getNodeProp(n, Tier.TierPropName);
691 if (t.getValue() == 0)
693 else if (t.getValue() > tier)
699 * Internal convenience routine to clear all the Tier values to 0. This
700 * cleanup is performed during cases such as Topology Change where the
701 * existing Tier values might become incorrect
703 private void clearTiers() {
704 Set<Node> nodes = null;
705 if (switchManager == null) {
706 logger.error("clearTiers(): Null switchManager");
709 nodes = switchManager.getNodes();
711 for (Node n : nodes) {
712 Tier t = new Tier(0);
713 switchManager.setNodeProp(n, t);
718 * Internal convenience routine to print the hierarchies of switches.
720 @SuppressWarnings("unused")
721 private void logHierarchies(ArrayList<ArrayList<String>> hierarchies) {
722 String hierarchyString = null;
724 for (ArrayList<String> hierarchy : hierarchies) {
725 StringBuffer buf = new StringBuffer();
726 buf.append("Hierarchy#" + num + " : ");
727 for (String switchName : hierarchy) {
728 buf.append(switchName + "/");
730 logger.debug("{} -> {}", getContainerName(), buf.toString());
736 * getHostNetworkHierarchy is the Back-end routine for the North-Bound API
737 * that returns the Network Hierarchy for a given Host. This API is
738 * typically used by applications like Hadoop for Rack Awareness
742 * IP-Address of the host/node.
743 * @return Network Hierarchies represented by an Array of Array (of
744 * Switch-Ids as String).
746 public List<List<String>> getHostNetworkHierarchy(InetAddress hostAddress) {
747 HostNodeConnector host = hostQuery(hostAddress);
751 List<List<String>> hierarchies = new ArrayList<List<String>>();
752 ArrayList<String> currHierarchy = new ArrayList<String>();
753 hierarchies.add(currHierarchy);
755 Node node = host.getnodeconnectorNode();
756 updateCurrentHierarchy(node, currHierarchy, hierarchies);
761 * dpidToHostNameHack is a hack function for Cisco Live Hadoop Demo. Mininet
762 * is used as the network for Hadoop Demos & in order to give a meaningful
763 * rack-awareness switch names, the DPID is organized in ASCII Characters
764 * and retrieved as string.
768 * @return Ascii String represented by the DPID.
770 private String dpidToHostNameHack(long dpid) {
771 String hex = Long.toHexString(dpid);
773 StringBuffer sb = new StringBuffer();
775 for (int i = 0; i < hex.length(); i++) {
776 result = (int) ((dpid >> (i * 8)) & 0xff);
781 sb.append(String.format("%c", result));
783 return sb.reverse().toString();
787 * A convenient recursive routine to obtain the Hierarchy of Switches.
790 * Current Node in the Recursive routine.
791 * @param currHierarchy
792 * Array of Nodes that make this hierarchy on which the Current
794 * @param fullHierarchy
795 * Array of multiple Hierarchies that represent a given host.
797 @SuppressWarnings("unchecked")
798 private void updateCurrentHierarchy(Node node,
799 ArrayList<String> currHierarchy, List<List<String>> fullHierarchy) {
800 // currHierarchy.add(String.format("%x", currSw.getId()));
801 currHierarchy.add(dpidToHostNameHack((Long) node.getID()));
802 ArrayList<String> currHierarchyClone = (ArrayList<String>) currHierarchy
803 .clone(); // Shallow copy as required
805 Map<Node, Set<Edge>> ndlinks = topologyManager.getNodeEdges();
806 if (ndlinks == null) {
808 "updateCurrentHierarchy(): topologyManager returned null ndlinks for node: {}",
812 Node n = NodeCreator.createOFNode((Long) node.getID());
813 Set<Edge> links = ndlinks.get(n);
815 logger.debug("updateCurrentHierarchy(): Null links for ndlinks");
818 for (Edge lt : links) {
819 if (!lt.getHeadNodeConnector().getType()
820 .equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
821 // We don't want to work on Node that are not openflow
825 Node dstNode = lt.getHeadNodeConnector().getNode();
827 Tier nodeTier = (Tier) switchManager.getNodeProp(node,
829 Tier dstNodeTier = (Tier) switchManager.getNodeProp(dstNode,
831 if (dstNodeTier.getValue() > nodeTier.getValue()) {
832 ArrayList<String> buildHierarchy = currHierarchy;
833 if (currHierarchy.size() > currHierarchyClone.size()) {
834 buildHierarchy = (ArrayList<String>) currHierarchyClone
835 .clone(); // Shallow copy as required
836 fullHierarchy.add(buildHierarchy);
838 updateCurrentHierarchy(dstNode, buildHierarchy, fullHierarchy);
843 private void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
845 Short srcPort = null;
847 Short dstPort = null;
848 boolean added = false;
849 String srcType = null;
850 String dstType = null;
852 if (e == null || type == null) {
853 logger.error("Edge or Update type are null!");
856 srcType = e.getTailNodeConnector().getType();
857 dstType = e.getHeadNodeConnector().getType();
859 if (srcType.equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
860 logger.debug("Skip updates for {}", e);
864 if (!srcType.equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
865 logger.error("For now we cannot handle updates for "
866 + "non-openflow nodes");
870 if (dstType.equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
871 logger.debug("Skip updates for {}", e);
875 if (!dstType.equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
876 logger.error("For now we cannot handle updates for "
877 + "non-openflow nodes");
881 // At this point we know we got an openflow update, so
882 // lets fill everything accordingly.
883 srcNid = (Long) e.getTailNodeConnector().getNode().getID();
884 srcPort = (Short) e.getTailNodeConnector().getID();
885 dstNid = (Long) e.getHeadNodeConnector().getNode().getID();
886 dstPort = (Short) e.getHeadNodeConnector().getID();
888 // Now lets update the added flag
900 "HostTracker Topology linkUpdate handling src:{}[port {}] dst:{}[port {}] added: {}",
901 new Object[] { srcNid, srcPort, dstNid, dstPort, added });
903 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
904 HostNodeConnector host = entry.getValue();
905 Node node = host.getnodeconnectorNode();
907 Tier t = new Tier(1);
908 switchManager.setNodeProp(node, t);
909 updateSwitchTiers(node, 1);
915 public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
916 for (int i = 0; i < topoedgeupdateList.size(); i++) {
917 Edge e = topoedgeupdateList.get(i).getEdge();
918 Set<Property> p = topoedgeupdateList.get(i).getProperty();
919 UpdateType type = topoedgeupdateList.get(i).getUpdateType();
920 edgeUpdate(e, type, p);
924 public void subnetNotify(Subnet sub, boolean add) {
925 logger.debug("Received subnet notification: {} add={}", sub, add);
927 for (int i = 0; i < failedARPReqList.size(); i++) {
929 arphost = failedARPReqList.get(i);
931 "Sending the ARP from FailedARPReqList fors IP: {}",
932 arphost.getHostIP().getHostAddress());
933 hostFinder.find(arphost.getHostIP());
938 class OutStandingARPHandler extends TimerTask {
941 /* This routine runs every 4 seconds */
942 // logger.info ("ARP Handler called");
943 for (int i = 0; i < ARPPendingList.size(); i++) {
944 arphost = ARPPendingList.get(i);
945 if (arphost.getSent_count() < switchManager.getHostRetryCount()) {
947 * No reply has been received of first ARP Req, send the
950 hostFinder.find(arphost.getHostIP());
951 arphost.sent_count++;
952 logger.debug("ARP Sent from ARPPending List, IP: {}",
953 arphost.getHostIP().getHostAddress());
954 } else if (arphost.getSent_count() >= switchManager
955 .getHostRetryCount()) {
957 * Two ARP requests have been sent without receiving a
958 * reply, remove this from the pending list
960 removePendingARPFromList(i);
962 "ARP reply not received after two attempts, removing from Pending List IP: {}",
963 arphost.getHostIP().getHostAddress());
965 * Add this host to a different list which will be processed
968 logger.debug("Adding the host to FailedARPReqList IP: {}",
969 arphost.getHostIP().getHostAddress());
970 failedARPReqList.add(arphost);
974 "Inavlid arp_sent count for entery at index: {}", i);
980 private class ARPRefreshHandler extends TimerTask {
981 @SuppressWarnings("deprecation")
983 if ((clusterContainerService != null)
984 && !clusterContainerService.amICoordinator()) {
987 if ((switchManager != null)
988 && !switchManager.isHostRefreshEnabled()) {
990 * The host probe procedure was disabled by CLI
994 if (hostsDB == null) {
995 /* hostsDB is not allocated yet */
996 logger.error("ARPRefreshHandler(): hostsDB is not allocated yet:");
999 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB
1001 HostNodeConnector host = entry.getValue();
1002 if (host.isStaticHost()) {
1003 /* this host was learned via API3, don't age it out */
1007 short arp_cntdown = host.getArpSendCountDown();
1009 if (arp_cntdown > switchManager.getHostRetryCount()) {
1010 host.setArpSendCountDown(arp_cntdown);
1011 } else if (arp_cntdown <= 0) {
1013 * No ARP Reply received in last 2 minutes, remove this host
1014 * and inform applications
1016 removeKnownHost(entry.getKey());
1017 notifyHostLearnedOrRemoved(host, false);
1018 } else if (arp_cntdown <= switchManager.getHostRetryCount()) {
1020 * Use the services of arphandler to check if host is still
1024 "ARP Probing ({}) for {}({})",
1027 host.getNetworkAddress().getHostAddress(),
1028 HexEncode.bytesToHexString(host
1029 .getDataLayerAddressBytes()) });
1030 host.setArpSendCountDown(arp_cntdown);
1031 hostFinder.probe(host);
1038 * Inform the controller IP to MAC binding of a host and its connectivity to
1039 * an openflow switch in terms of Node, port, and VLAN.
1041 * @param networkAddr
1042 * IP address of the host
1044 * Address MAC address of the host
1046 * NodeConnector to which host is connected
1048 * Port of the switch to which host is connected
1050 * Vlan of which this host is member of
1052 * @return Status The status object as described in {@code Status}
1053 * indicating the result of this action.
1056 public Status addStaticHostReq(InetAddress networkAddr,
1057 byte[] dataLayerAddress, NodeConnector nc, short vlan) {
1058 if (dataLayerAddress.length != 6) {
1059 return new Status(StatusCode.BADREQUEST, "Invalid MAC address");
1062 HostNodeConnector host = null;
1064 host = new HostNodeConnector(dataLayerAddress, networkAddr, nc,
1066 if (hostExists(host)) {
1067 // This host is already learned either via ARP or through a
1068 // northbound request
1069 HostNodeConnector transHost = hostsDB.get(networkAddr);
1070 transHost.setStaticHost(true);
1071 return new Status(StatusCode.SUCCESS, null);
1073 host.setStaticHost(true);
1075 * Before adding host, Check if the switch and the port have already
1078 if (switchManager.isNodeConnectorEnabled(nc)) {
1080 notifyHostLearnedOrRemoved(host, true);
1082 inactiveStaticHosts.put(nc, host);
1084 "Switch or switchport is not up, adding host {} to inactive list",
1085 networkAddr.getHostName());
1087 return new Status(StatusCode.SUCCESS, null);
1088 } catch (ConstructionException e) {
1089 return new Status(StatusCode.INTERNALERROR,
1090 "Host could not be created");
1096 * Update the controller IP to MAC binding of a host and its connectivity to
1097 * an openflow switch in terms of switch id, switch port, and VLAN.
1099 * @param networkAddr
1100 * IP address of the host
1102 * Address MAC address of the host
1104 * NodeConnector to which host is connected
1106 * Port of the switch to which host is connected
1108 * Vlan of which this host is member of
1110 * @return boolean true if the host was added successfully, false otherwise
1112 public boolean updateHostReq(InetAddress networkAddr,
1113 byte[] dataLayerAddress, NodeConnector nc, short vlan) {
1117 HostNodeConnector host = null;
1119 host = new HostNodeConnector(dataLayerAddress, networkAddr, nc,
1121 if (!hostExists(host)) {
1122 if ((inactiveStaticHosts.get(nc)) != null) {
1123 inactiveStaticHosts.replace(nc, host);
1128 hostsDB.replace(networkAddr, host);
1130 } catch (ConstructionException e) {
1136 * Remove from the controller IP to MAC binding of a host and its
1137 * connectivity to an openflow switch
1139 * @param networkAddr
1140 * IP address of the host
1142 * @return boolean true if the host was removed successfully, false
1146 public Status removeStaticHostReq(InetAddress networkAddress) {
1147 // Check if host is in active hosts database
1148 HostNodeConnector host = getHostFromOnActiveDB(networkAddress);
1151 if (!host.isStaticHost()) {
1152 return new Status(StatusCode.FORBIDDEN, "Host "
1153 + networkAddress.getHostName() + " is not static");
1155 // Remove and notify
1156 notifyHostLearnedOrRemoved(host, false);
1157 removeKnownHost(networkAddress);
1158 return new Status(StatusCode.SUCCESS, null);
1161 // Check if host is in inactive hosts database
1162 Entry<NodeConnector, HostNodeConnector> entry = getHostFromInactiveDB(networkAddress);
1163 if (entry != null) {
1164 host = entry.getValue();
1166 if (!host.isStaticHost()) {
1167 return new Status(StatusCode.FORBIDDEN, "Host "
1168 + networkAddress.getHostName() + " is not static");
1170 this.removeHostFromInactiveDB(networkAddress);
1171 return new Status(StatusCode.SUCCESS, null);
1174 // Host is neither in active nor inactive hosts database
1175 return new Status(StatusCode.NOTFOUND, "Host does not exist");
1179 public void modeChangeNotify(Node node, boolean proactive) {
1180 logger.debug("Set Switch {} Mode to {}", node.getID(), proactive);
1184 public void notifyNode(Node node, UpdateType type,
1185 Map<String, Property> propMap) {
1191 long sid = (Long) node.getID();
1192 logger.debug("Received removedSwitch for sw id {}",
1193 HexEncode.longToHexString(sid));
1194 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB
1196 HostNodeConnector host = entry.getValue();
1197 if (host.getnodeconnectornodeId() == sid) {
1198 logger.debug("Switch: {} is down, remove from Hosts_DB",
1200 removeKnownHost(entry.getKey());
1201 notifyHostLearnedOrRemoved(host, false);
1211 public void notifyNodeConnector(NodeConnector nodeConnector,
1212 UpdateType type, Map<String, Property> propMap) {
1213 if (nodeConnector == null)
1224 State state = (State) propMap.get(State.StatePropName);
1225 if ((state != null) && (state.getValue() == State.EDGE_UP)) {
1234 handleNodeConnectorStatusUp(nodeConnector);
1236 handleNodeConnectorStatusDown(nodeConnector);
1241 public Status addStaticHost(String networkAddress, String dataLayerAddress,
1242 NodeConnector nc, String vlan) {
1244 InetAddress ip = InetAddress.getByName(networkAddress);
1246 return new Status(StatusCode.BADREQUEST, "Invalid NodeId");
1248 return addStaticHostReq(ip,
1249 HexEncode.bytesFromHexString(dataLayerAddress), nc,
1250 Short.valueOf(vlan));
1251 } catch (UnknownHostException e) {
1252 logger.error("", e);
1253 return new Status(StatusCode.BADREQUEST, "Invalid Address");
1258 public Status removeStaticHost(String networkAddress) {
1259 InetAddress address;
1261 address = InetAddress.getByName(networkAddress);
1262 return removeStaticHostReq(address);
1263 } catch (UnknownHostException e) {
1264 logger.error("", e);
1265 return new Status(StatusCode.BADREQUEST, "Invalid Address");
1269 private void handleNodeConnectorStatusUp(NodeConnector nodeConnector) {
1272 logger.debug("handleNodeConnectorStatusUp {}", nodeConnector);
1274 for (int i = 0; i < failedARPReqList.size(); i++) {
1275 arphost = failedARPReqList.get(i);
1276 logger.debug("Sending the ARP from FailedARPReqList fors IP: {}",
1277 arphost.getHostIP().getHostAddress());
1278 hostFinder.find(arphost.getHostIP());
1280 HostNodeConnector host = inactiveStaticHosts.get(nodeConnector);
1282 inactiveStaticHosts.remove(nodeConnector);
1284 notifyHostLearnedOrRemoved(host, true);
1288 private void handleNodeConnectorStatusDown(NodeConnector nodeConnector) {
1289 long sid = (Long) nodeConnector.getNode().getID();
1290 short port = (Short) nodeConnector.getID();
1292 logger.debug("handleNodeConnectorStatusDown {}", nodeConnector);
1294 for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
1295 HostNodeConnector host = entry.getValue();
1296 if ((host.getnodeconnectornodeId() == sid)
1297 && (host.getnodeconnectorportId() == port)) {
1299 "Switch: {}, Port: {} is down, remove from Hosts_DB",
1301 removeKnownHost(entry.getKey());
1302 notifyHostLearnedOrRemoved(host, false);
1307 void setClusterContainerService(IClusterContainerServices s) {
1308 logger.debug("Cluster Service set");
1309 this.clusterContainerService = s;
1312 void unsetClusterContainerService(IClusterContainerServices s) {
1313 if (this.clusterContainerService == s) {
1314 logger.debug("Cluster Service removed!");
1315 this.clusterContainerService = null;
1319 void setSwitchManager(ISwitchManager s) {
1320 logger.debug("SwitchManager set");
1321 this.switchManager = s;
1324 void unsetSwitchManager(ISwitchManager s) {
1325 if (this.switchManager == s) {
1326 logger.debug("SwitchManager removed!");
1327 this.switchManager = null;
1331 public String getContainerName() {
1332 if (containerName == null)
1333 return GlobalConstants.DEFAULT.toString();
1334 return containerName;
1338 * Function called by the dependency manager when all the required
1339 * dependencies are satisfied
1342 void init(Component c) {
1343 Dictionary<?, ?> props = c.getServiceProperties();
1344 if (props != null) {
1345 this.containerName = (String) props.get("containerName");
1346 logger.debug("Running containerName: {}", this.containerName);
1348 // In the Global instance case the containerName is empty
1349 this.containerName = "";
1355 * Function called by the dependency manager when at least one dependency
1356 * become unsatisfied or when the component is shutting down because for
1357 * example bundle is being stopped.
1365 * Function called by dependency manager after "init ()" is called and after
1366 * the services provided by the class are registered in the service registry
1373 * Function called by the dependency manager before the services exported by
1374 * the component are unregistered, this will be followed by a "destroy ()"
1382 public void edgeOverUtilized(Edge edge) {
1383 // TODO Auto-generated method stub
1388 public void edgeUtilBackToNormal(Edge edge) {
1389 // TODO Auto-generated method stub