import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
static final String ACTIVE_HOST_CACHE = "hosttracker.ActiveHosts";
static final String INACTIVE_HOST_CACHE = "hosttracker.InactiveHosts";
private static final Logger logger = LoggerFactory.getLogger(HostTracker.class);
- protected IHostFinder hostFinder;
+ protected final Set<IHostFinder> hostFinder = new CopyOnWriteArraySet<IHostFinder>();;
protected ConcurrentMap<InetAddress, HostNodeConnector> hostsDB;
/*
* Following is a list of hosts which have been requested by NB APIs to be
private String containerName = null;
private ExecutorService executor;
protected boolean stopping;
+ private static boolean hostRefresh = true;
+ private static int hostRetryCount = 5;
private static class ARPPending {
protected InetAddress hostIP;
protected short sent_count;
}
public void setArpHandler(IHostFinder hostFinder) {
- this.hostFinder = hostFinder;
+ if (this.hostFinder != null) {
+ this.hostFinder.add(hostFinder);
+ }
}
public void unsetArpHandler(IHostFinder hostFinder) {
- if (this.hostFinder == hostFinder) {
+ if (this.hostFinder != null) {
logger.debug("Arp Handler Service removed!");
- this.hostFinder = null;
+ this.hostFinder.remove(hostFinder);
}
}
@Override
public Future<HostNodeConnector> discoverHost(InetAddress networkAddress) {
if (executor == null) {
- logger.error("discoverHost: Null executor");
+ logger.debug("discoverHost: Null executor");
return null;
}
Callable<HostNodeConnector> worker = new HostTrackerCallable(this, networkAddress);
networkAddress.getHostAddress());
/* host is not found, initiate a discovery */
-
- hostFinder.find(networkAddress);
+ for (IHostFinder hf : hostFinder) {
+ hf.find(networkAddress);
+ }
return null;
}
@Override
public Set<HostNodeConnector> getAllHosts() {
- Set<HostNodeConnector> allHosts = new HashSet<HostNodeConnector>();
- for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
- HostNodeConnector host = entry.getValue();
- allHosts.add(host);
- }
- logger.debug("Exiting getAllHosts, Found {} Hosts", allHosts.size());
+ Set<HostNodeConnector> allHosts = new HashSet<HostNodeConnector>(hostsDB.values());
return allHosts;
}
list.add(host);
}
}
- logger.debug("getActiveStaticHosts(): Found {} Hosts", list.size());
return list;
}
@Override
public Set<HostNodeConnector> getInactiveStaticHosts() {
- Set<HostNodeConnector> list = new HashSet<HostNodeConnector>();
- for (Entry<NodeConnector, HostNodeConnector> entry : inactiveStaticHosts.entrySet()) {
- list.add(entry.getValue());
- }
- logger.debug("getInactiveStaticHosts(): Found {} Hosts", list.size());
+ Set<HostNodeConnector> list = new HashSet<HostNodeConnector>(inactiveStaticHosts.values());
return list;
}
@Override
public void hostListener(HostNodeConnector host) {
-
- logger.debug("ARP received for Host: IP {}, MAC {}, {}", host.getNetworkAddress().getHostAddress(),
+ logger.debug("Received for Host: IP {}, MAC {}, {}", host.getNetworkAddress().getHostAddress(),
HexEncode.bytesToHexString(host.getDataLayerAddressBytes()), host);
if (hostExists(host)) {
HostNodeConnector existinghost = hostsDB.get(host.getNetworkAddress());
existinghost.initArpSendCountDown();
+ // Update the host
+ hostsDB.put(host.getNetworkAddress(), existinghost);
return;
}
new NotifyHostThread(host).start();
ta.notifyHTClientHostRemoved(host);
}
} catch (Exception e) {
- logger.error("Exception on callback", e);
+ logger.error("Exception on new host notification", e);
}
}
}
int num = 1;
for (ArrayList<String> hierarchy : hierarchies) {
StringBuffer buf = new StringBuffer();
- buf.append("Hierarchy#" + num + " : ");
+ buf.append("Hierarchy#").append(num).append(" : ");
for (String switchName : hierarchy) {
- buf.append(switchName + "/");
+ buf.append(switchName).append("/");
}
logger.debug("{} -> {}", getContainerName(), buf);
num++;
*/
@SuppressWarnings("unchecked")
private void updateCurrentHierarchy(Node node, ArrayList<String> currHierarchy, List<List<String>> fullHierarchy) {
- // currHierarchy.add(String.format("%x", currSw.getId()));
currHierarchy.add(dpidToHostNameHack((Long) node.getID()));
// Shallow copy as required
ArrayList<String> currHierarchyClone = (ArrayList<String>) currHierarchy.clone();
continue;
}
logger.debug("Sending the ARP from FailedARPReqList fors IP: {}", arphost.getHostIP().getHostAddress());
- hostFinder.find(arphost.getHostIP());
+ for (IHostFinder hf : hostFinder) {
+ hf.find(arphost.getHostIP());
+ }
}
}
}
ARPPendingList.remove(entry.getKey());
continue;
}
- if (arphost.getSent_count() < switchManager.getHostRetryCount()) {
+ if (arphost.getSent_count() < hostRetryCount) {
/*
* No reply has been received of first ARP Req, send the
* next one. Before sending the ARP, check if ARPHandler is
logger.warn("ARPHandler Services are not available for Outstanding ARPs");
continue;
}
- hostFinder.find(arphost.getHostIP());
+ for (IHostFinder hf : hostFinder) {
+ hf.find(arphost.getHostIP());
+ }
arphost.sent_count++;
logger.debug("ARP Sent from ARPPending List, IP: {}", arphost.getHostIP().getHostAddress());
- } else if (arphost.getSent_count() >= switchManager.getHostRetryCount()) {
+ } else if (arphost.getSent_count() >= hostRetryCount) {
/*
* ARP requests have been sent without receiving a reply,
* remove this from the pending list
if ((clusterContainerService != null) && !clusterContainerService.amICoordinator()) {
return;
}
- if ((switchManager != null) && !switchManager.isHostRefreshEnabled()) {
+ if (!hostRefresh) {
/*
- * The host probe procedure was disabled by CLI
+ * The host probe procedure is turned off
*/
return;
}
short arp_cntdown = host.getArpSendCountDown();
arp_cntdown--;
- if (arp_cntdown > switchManager.getHostRetryCount()) {
+ if (arp_cntdown > hostRetryCount) {
host.setArpSendCountDown(arp_cntdown);
} else if (arp_cntdown <= 0) {
/*
*/
removeKnownHost(entry.getKey());
notifyHostLearnedOrRemoved(host, false);
- } else if (arp_cntdown <= switchManager.getHostRetryCount()) {
+ } else if (arp_cntdown <= hostRetryCount) {
/*
* Use the services of arphandler to check if host is still
* there
* probe. However, continue the age out the hosts since
* we don't know if the host is indeed out there or not.
*/
- logger.warn("ARPHandler is not avaialable, can't send the probe");
+ logger.trace("ARPHandler is not avaialable, can't send the probe");
continue;
}
- hostFinder.probe(host);
+ for (IHostFinder hf : hostFinder) {
+ hf.probe(host);
+ }
}
}
}
* indicating the result of this action.
*/
- public Status addStaticHostReq(InetAddress networkAddr, byte[] dataLayerAddress, NodeConnector nc, short vlan) {
+ protected Status addStaticHostReq(InetAddress networkAddr, byte[] dataLayerAddress, NodeConnector nc, short vlan) {
if (dataLayerAddress.length != NetUtils.MACAddrLengthInBytes) {
return new Status(StatusCode.BADREQUEST, "Invalid MAC address");
}
// northbound request
HostNodeConnector transHost = hostsDB.get(networkAddr);
transHost.setStaticHost(true);
- return new Status(StatusCode.SUCCESS, null);
+ return new Status(StatusCode.SUCCESS);
}
if (hostsDB.get(networkAddr) != null) {
// There is already a host with this IP address (but behind
// a different (switch, port, vlan) tuple. Return an error
- return new Status(StatusCode.CONFLICT, "Existing IP, Use PUT to update");
+ return new Status(StatusCode.CONFLICT, "Host with this IP already exists.");
}
host.setStaticHost(true);
/*
logger.debug("Switch or switchport is not up, adding host {} to inactive list",
networkAddr.getHostName());
}
- return new Status(StatusCode.SUCCESS, null);
+ return new Status(StatusCode.SUCCESS);
} catch (ConstructionException e) {
logger.error("", e);
return new Status(StatusCode.INTERNALERROR, "Host could not be created");
public Status addStaticHost(String networkAddress, String dataLayerAddress, NodeConnector nc, String vlan) {
try {
InetAddress ip = InetAddress.getByName(networkAddress);
- if (nc == null) {
- return new Status(StatusCode.BADREQUEST, "Invalid NodeId");
+ short vl = 0;
+ if (vlan != null && !vlan.isEmpty()) {
+ vl = Short.decode(vlan);
+ if (vl < 1 || vl > 4095) {
+ return new Status(StatusCode.BADREQUEST, "Host vlan out of range [1 - 4095]");
+ }
}
- return addStaticHostReq(ip, HexEncode.bytesFromHexString(dataLayerAddress), nc, Short.valueOf(vlan));
+
+ return addStaticHostReq(ip, HexEncode.bytesFromHexString(dataLayerAddress), nc, vl);
+
} catch (UnknownHostException e) {
- logger.error("", e);
- return new Status(StatusCode.BADREQUEST, "Invalid Address");
+ logger.debug("Invalid host IP specified when adding static host", e);
+ return new Status(StatusCode.BADREQUEST, "Invalid Host IP Address");
+ } catch (NumberFormatException nfe) {
+ logger.debug("Invalid host vlan or MAC specified when adding static host", nfe);
+ return new Status(StatusCode.BADREQUEST, "Invalid Host vLan/MAC");
}
}
@Override
public Status removeStaticHost(String networkAddress) {
- InetAddress address;
try {
- address = InetAddress.getByName(networkAddress);
+ InetAddress address = InetAddress.getByName(networkAddress);
return removeStaticHostReq(address);
} catch (UnknownHostException e) {
- logger.error("", e);
- return new Status(StatusCode.BADREQUEST, "Invalid Address");
+ logger.debug("Invalid IP Address when trying to remove host", e);
+ return new Status(StatusCode.BADREQUEST, "Invalid IP Address when trying to remove host");
}
}
ARPPending arphost;
HostNodeConnector host = null;
- logger.debug("handleNodeConnectorStatusUp {}", nodeConnector);
+ logger.trace("handleNodeConnectorStatusUp {}", nodeConnector);
for (Entry<InetAddress, ARPPending> entry : failedARPReqList.entrySet()) {
arphost = entry.getValue();
- logger.debug("Sending the ARP from FailedARPReqList fors IP: {}", arphost.getHostIP().getHostAddress());
+ logger.trace("Sending the ARP from FailedARPReqList fors IP: {}", arphost.getHostIP().getHostAddress());
if (hostFinder == null) {
logger.warn("ARPHandler is not available at interface up");
logger.warn("Since this event is missed, host(s) connected to interface {} may not be discovered",
try {
byte[] dataLayerAddress = NetUtils.getBroadcastMACAddr();
host = new HostNodeConnector(dataLayerAddress, arphost.getHostIP(), nodeConnector, (short) 0);
- hostFinder.probe(host);
+ for (IHostFinder hf : hostFinder) {
+ hf.probe(host);
+ }
} catch (ConstructionException e) {
logger.debug("HostNodeConnector couldn't be created for Host: {}, NodeConnector: {}",
arphost.getHostIP(), nodeConnector);
logger.error("", e);
}
- logger.debug("Done. handleNodeConnectorStatusUp {}", nodeConnector);
}
host = inactiveStaticHosts.get(nodeConnector);
}
private void handleNodeConnectorStatusDown(NodeConnector nodeConnector) {
- logger.debug("handleNodeConnectorStatusDown {}", nodeConnector);
+ logger.trace("handleNodeConnectorStatusDown {}", nodeConnector);
for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
HostNodeConnector host = entry.getValue();