<configuration>
<instructions>
<Import-Package>
+ org.opendaylight.controller.connectionmanager,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.switchmanager,
org.opendaylight.controller.topologymanager,
+ org.opendaylight.controller.clustering.services,
org.opendaylight.controller.hosttracker,
org.opendaylight.controller.hosttracker.hostAware,
org.apache.felix.dm,
org.osgi.service.component,
org.slf4j
</Import-Package>
+ <Export-Package>
+ org.opendaylight.controller.arphandler
+ </Export-Package>
<Bundle-Activator>
org.opendaylight.controller.arphandler.internal.Activator
</Bundle-Activator>
<groupId>org.opendaylight.controller</groupId>
<artifactId>switchmanager</artifactId>
<version>0.5.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
--- /dev/null
+
+/*
+ * 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.arphandler;
+
+import java.io.Serializable;
+import java.net.InetAddress;
+/*
+ * ARP Event base class
+ */
+public abstract class ARPEvent implements Serializable{
+
+ private static final long serialVersionUID = 1L;
+ private final InetAddress tIP;
+
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = prime + ((tIP == null) ? 0 : tIP.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof ARPEvent)) {
+ return false;
+ }
+ ARPEvent other = (ARPEvent) obj;
+ if (tIP == null) {
+ if (other.tIP != null) {
+ return false;
+ }
+ } else if (!tIP.equals(other.tIP)) {
+ return false;
+ }
+ return true;
+ }
+
+ public ARPEvent(InetAddress ip) {
+ this.tIP = ip;
+ }
+
+ public InetAddress getTargetIP() {
+ return tIP;
+ }
+}
--- /dev/null
+
+/*
+ * 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.arphandler;
+
+import java.net.InetAddress;
+import java.util.Arrays;
+
+import org.opendaylight.controller.sal.core.NodeConnector;
+/*
+ * ARP Reply event wrapper
+ */
+public class ARPReply extends ARPEvent {
+
+ private final NodeConnector port;
+ private final byte[] tMac;
+ private final byte[] sMac;
+ private final InetAddress sIP;
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = super.hashCode();
+ result = prime * result + ((sIP == null) ? 0 : sIP.hashCode());
+ result = prime * result + Arrays.hashCode(sMac);
+ result = prime * result + Arrays.hashCode(tMac);
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof ARPReply)) {
+ return false;
+ }
+ ARPReply other = (ARPReply) obj;
+ if (sIP == null) {
+ if (other.sIP != null) {
+ return false;
+ }
+ } else if (!sIP.equals(other.sIP)) {
+ return false;
+ }
+ if (!Arrays.equals(sMac, other.sMac)) {
+ return false;
+ }
+ if (!Arrays.equals(tMac, other.tMac)) {
+ return false;
+ }
+ return true;
+ }
+
+ public ARPReply(NodeConnector port, InetAddress sIP, byte[] sMAC, InetAddress tIP, byte[] tMAC) {
+ super(tIP);
+ this.tMac = tMAC;
+ this.sIP = sIP;
+ this.sMac = sMAC;
+ this.port = port;
+ }
+
+ public ARPReply(InetAddress tIP, byte[] tMAC) {
+ super(tIP);
+ this.tMac = tMAC;
+ this.sIP = null;
+ this.sMac = null;
+ this.port = null;
+ }
+
+ public byte[] getTargetMac() {
+ return tMac;
+ }
+
+ public byte[] getSourceMac() {
+ return sMac;
+ }
+
+ public InetAddress getSourceIP() {
+ return sIP;
+ }
+
+ public NodeConnector getPort() {
+ return port;
+ }
+}
--- /dev/null
+
+/*
+ * 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.arphandler;
+
+import java.net.InetAddress;
+
+import org.opendaylight.controller.arphandler.ARPEvent;
+import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
+import org.opendaylight.controller.switchmanager.Subnet;
+/*
+ * ARP Request event wrapper Consists of IP and Subnet (and a
+ * HostNodeConnector if is unicast) For unicast request, construct with a
+ * specified host
+ */
+public class ARPRequest extends ARPEvent {
+ private final Subnet subnet;
+ private final HostNodeConnector host;
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = super.hashCode();
+ result = prime * result + ((host == null) ? 0 : host.hashCode());
+ result = prime * result + ((subnet == null) ? 0 : subnet.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof ARPRequest)) {
+ return false;
+ }
+ ARPRequest other = (ARPRequest) obj;
+ if (host == null) {
+ if (other.host != null) {
+ return false;
+ }
+ } else if (!host.equals(other.host)) {
+ return false;
+ }
+ if (subnet == null) {
+ if (other.subnet != null) {
+ return false;
+ }
+ } else if (!subnet.equals(other.subnet)) {
+ return false;
+ }
+ return true;
+ }
+
+ // broadcast
+ public ARPRequest(InetAddress ip, Subnet subnet) {
+ super(ip);
+ this.subnet = subnet;
+ this.host = null;
+ }
+
+ // unicast
+ public ARPRequest(HostNodeConnector host, Subnet subnet) {
+ super(host.getNetworkAddress());
+ this.host = host;
+ this.subnet = subnet;
+ }
+
+ public Subnet getSubnet() {
+ return subnet;
+ }
+
+ public HostNodeConnector getHost() {
+ return host;
+ }
+}
package org.opendaylight.controller.arphandler.internal;
-import java.util.Hashtable;
import java.util.Dictionary;
-import org.apache.felix.dm.Component;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Set;
+import org.apache.felix.dm.Component;
+import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
+import org.opendaylight.controller.clustering.services.IClusterContainerServices;
+import org.opendaylight.controller.connectionmanager.IConnectionManager;
import org.opendaylight.controller.hosttracker.IfHostListener;
import org.opendaylight.controller.hosttracker.IfIptoHost;
import org.opendaylight.controller.hosttracker.hostAware.IHostFinder;
import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
-import org.opendaylight.controller.sal.packet.IListenDataPacket;
import org.opendaylight.controller.sal.packet.IDataPacketService;
+import org.opendaylight.controller.sal.packet.IListenDataPacket;
import org.opendaylight.controller.switchmanager.ISwitchManager;
import org.opendaylight.controller.topologymanager.ITopologyManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Activator extends ComponentActivatorAbstractBase {
protected static final Logger logger = LoggerFactory
public void configureInstance(Component c, Object imp, String containerName) {
if (imp.equals(ArpHandler.class)) {
// export the service
- Dictionary<String, String> props = new Hashtable<String, String>();
+ Dictionary<String, Object> props = new Hashtable<String, Object>();
props.put("salListenerName", "arphandler");
- c.setInterface(new String[] { IHostFinder.class.getName(),
- IListenDataPacket.class.getName() }, props);
+ Set<String> propSet = new HashSet<String>();
+ propSet.add(ArpHandler.ARP_EVENT_CACHE_NAME);
+ props.put("cachenames", propSet);
+
+ c.setInterface(new String[] {
+ IHostFinder.class.getName(),
+ IListenDataPacket.class.getName(),
+ ICacheUpdateAware.class.getName()}, props);
+
+ // We need connection mgr to distribute packet out across the cluster
+ c.add(createServiceDependency().setService(
+ IConnectionManager.class).setCallbacks("setConnectionManager",
+ "unsetConnectionManager").setRequired(true));
+
c.add(createContainerServiceDependency(containerName).setService(
ISwitchManager.class).setCallbacks("setSwitchManager",
ITopologyManager.class).setCallbacks("setTopologyManager",
"unsetTopologyMananger").setRequired(true));
- c.add(createContainerServiceDependency(containerName).setService(
+ c.add(createContainerServiceDependency(containerName).setService(
IDataPacketService.class).setCallbacks(
"setDataPacketService", "unsetDataPacketService")
.setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IClusterContainerServices.class).setCallbacks(
+ "setClusterContainerService", "unsetClusterContainerService")
+ .setRequired(true));
+
// the Host Listener is optional
c.add(createContainerServiceDependency(containerName).setService(
IfHostListener.class).setCallbacks("setHostListener",
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Collections;
+import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import org.opendaylight.controller.arphandler.ARPEvent;
+import org.opendaylight.controller.arphandler.ARPReply;
+import org.opendaylight.controller.arphandler.ARPRequest;
+import org.opendaylight.controller.clustering.services.CacheConfigException;
+import org.opendaylight.controller.clustering.services.CacheExistException;
+import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
+import org.opendaylight.controller.clustering.services.IClusterContainerServices;
+import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.connectionmanager.IConnectionManager;
import org.opendaylight.controller.hosttracker.IfHostListener;
import org.opendaylight.controller.hosttracker.IfIptoHost;
import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.packet.ARP;
-import org.opendaylight.controller.sal.packet.BitBufferHelper;
import org.opendaylight.controller.sal.packet.Ethernet;
import org.opendaylight.controller.sal.packet.IDataPacketService;
import org.opendaylight.controller.sal.packet.IListenDataPacket;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class ArpHandler implements IHostFinder, IListenDataPacket {
- private static final Logger logger = LoggerFactory
- .getLogger(ArpHandler.class);
- private IfIptoHost hostTracker = null;
- private ISwitchManager switchManager = null;
+public class ArpHandler implements IHostFinder, IListenDataPacket, ICacheUpdateAware<ARPEvent, Boolean> {
+ private static final Logger log = LoggerFactory.getLogger(ArpHandler.class);
+ static final String ARP_EVENT_CACHE_NAME = "arphandler.arpRequestReplyEvent";
+ private IfIptoHost hostTracker;
+ private ISwitchManager switchManager;
private ITopologyManager topologyManager;
- private IDataPacketService dataPacketService = null;
- private Set<IfHostListener> hostListener = Collections
- .synchronizedSet(new HashSet<IfHostListener>());
+ private IDataPacketService dataPacketService;
+ private IClusterContainerServices clusterContainerService;
+ private IConnectionManager connectionManager;
+ private Set<IfHostListener> hostListeners = new CopyOnWriteArraySet<IfHostListener>();
private ConcurrentMap<InetAddress, Set<HostNodeConnector>> arpRequestors;
private ConcurrentMap<InetAddress, Short> countDownTimers;
private Timer periodicTimer;
+ /*
+ * A cluster allocated cache. Used for synchronizing ARP request/reply
+ * events across all cluster controllers. To raise an event, we put() a specific
+ * event object (as key) and all nodes handle it in the entryUpdated callback.
+ *
+ * In case of ARPReply, we put true value to send replies to any requestors
+ * by calling generateAndSendReply
+ */
+ private ConcurrentMap<ARPEvent, Boolean> arpRequestReplyEvent;
+
+ void setConnectionManager(IConnectionManager cm){
+ this.connectionManager = cm;
+ }
+
+ void unsetConnectionManager(IConnectionManager cm){
+ if (this.connectionManager == cm){
+ connectionManager = null;
+ }
+ }
+
+ void setClusterContainerService(IClusterContainerServices s){
+ this.clusterContainerService = s;
+ }
+
+ void unsetClusterContainerService(IClusterContainerServices s) {
+ if (this.clusterContainerService == s) {
+ this.clusterContainerService = null;
+ }
+ }
void setHostListener(IfHostListener s) {
- if (this.hostListener != null) {
- this.hostListener.add(s);
+ if (this.hostListeners != null) {
+ this.hostListeners.add(s);
}
}
void unsetHostListener(IfHostListener s) {
- if (this.hostListener != null) {
- this.hostListener.remove(s);
+ if (this.hostListeners != null) {
+ this.hostListeners.remove(s);
}
}
}
}
- public IfIptoHost getHostTracker() {
- return hostTracker;
- }
-
public void setHostTracker(IfIptoHost hostTracker) {
- logger.debug("Setting HostTracker");
+ log.debug("Setting HostTracker");
this.hostTracker = hostTracker;
}
public void unsetHostTracker(IfIptoHost s) {
- logger.debug("UNSetting HostTracker");
+ log.debug("UNSetting HostTracker");
if (this.hostTracker == s) {
this.hostTracker = null;
}
byte[] senderIP = sIP.getAddress();
byte[] targetIP = tIP.getAddress();
ARP arp = new ARP();
- arp.setHardwareType(ARP.HW_TYPE_ETHERNET).setProtocolType(
- EtherTypes.IPv4.shortValue())
- .setHardwareAddressLength((byte) 6).setProtocolAddressLength(
- (byte) 4).setOpCode(ARP.REPLY)
- .setSenderHardwareAddress(sMAC).setSenderProtocolAddress(
- senderIP).setTargetHardwareAddress(tMAC)
- .setTargetProtocolAddress(targetIP);
+ arp.setHardwareType(ARP.HW_TYPE_ETHERNET)
+ .setProtocolType(EtherTypes.IPv4.shortValue())
+ .setHardwareAddressLength((byte) 6)
+ .setProtocolAddressLength((byte) 4)
+ .setOpCode(ARP.REPLY)
+ .setSenderHardwareAddress(sMAC)
+ .setSenderProtocolAddress(senderIP)
+ .setTargetHardwareAddress(tMAC)
+ .setTargetProtocolAddress(targetIP);
Ethernet ethernet = new Ethernet();
- ethernet.setSourceMACAddress(sMAC).setDestinationMACAddress(tMAC)
- .setEtherType(EtherTypes.ARP.shortValue()).setPayload(arp);
+ ethernet.setSourceMACAddress(sMAC)
+ .setDestinationMACAddress(tMAC)
+ .setEtherType(EtherTypes.ARP.shortValue())
+ .setPayload(arp);
RawPacket destPkt = this.dataPacketService.encodeDataPacket(ethernet);
destPkt.setOutgoingNodeConnector(p);
this.dataPacketService.transmitDataPacket(destPkt);
}
- private boolean isBroadcastMAC(byte[] mac) {
- if (BitBufferHelper.toNumber(mac) == 0xffffffffffffL) { //TODO: implement this in our Ethernet
- return true;
- }
- return false;
- }
-
- private boolean isUnicastMAC(byte[] mac) {
- if ((BitBufferHelper.toNumber(mac) & 0x010000000000L) == 0) {
- return true;
- }
- return false;
- }
-
protected void handleARPPacket(Ethernet eHeader, ARP pkt, NodeConnector p) {
- if (pkt.getOpCode() == 0x1) {
- logger.debug("Received ARP REQUEST Packet from NodeConnector: {}",
- p);
- } else {
- logger.debug("Received ARP REPLY Packet from NodeConnector: {}",
- p);
- }
- InetAddress targetIP = null;
- try {
- targetIP = InetAddress.getByAddress(pkt.getTargetProtocolAddress());
- } catch (UnknownHostException e1) {
- return;
- }
- InetAddress sourceIP = null;
- try {
- sourceIP = InetAddress.getByAddress(pkt.getSenderProtocolAddress());
- } catch (UnknownHostException e1) {
- return;
- }
- byte[] targetMAC = eHeader.getDestinationMACAddress();
- byte[] sourceMAC = eHeader.getSourceMACAddress();
+ byte[] sourceMAC = eHeader.getSourceMACAddress();
+ byte[] targetMAC = eHeader.getDestinationMACAddress();
/*
* Sanity Check; drop ARP packets originated by the controller itself.
* This is to avoid continuous flooding
*/
if (Arrays.equals(sourceMAC, getControllerMAC())) {
- if (logger.isDebugEnabled()) {
- logger.debug(
- "Receive the self originated packet (srcMAC {}) --> DROP",
- HexEncode.bytesToHexString(sourceMAC));
+ if (log.isDebugEnabled()) {
+ log.debug("Receive a self originated ARP pkt (srcMAC {}) --> DROP",
+ HexEncode.bytesToHexString(sourceMAC));
}
return;
}
+ InetAddress targetIP, sourceIP;
+ try {
+ targetIP = InetAddress.getByAddress(pkt.getTargetProtocolAddress());
+ sourceIP = InetAddress.getByAddress(pkt.getSenderProtocolAddress());
+ } catch (UnknownHostException e1) {
+ log.debug("Invalid host in ARP packet: {}", e1.getMessage());
+ return;
+ }
+
Subnet subnet = null;
if (switchManager != null) {
subnet = switchManager.getSubnetByNetworkAddress(sourceIP);
}
if (subnet == null) {
- logger.debug("can't find subnet matching {}, drop packet",sourceIP);
+ log.debug("ARPHandler: can't find subnet matching {}, drop packet", sourceIP);
return;
}
- logger.debug("Found {} matching {}", subnet, sourceIP);
- /*
- * Make sure that the host is a legitimate member of this subnet
- */
+
+ // Make sure that the host is a legitimate member of this subnet
if (!subnet.hasNodeConnector(p)) {
- logger.debug("{} showing up on {} does not belong to {}",
+ log.debug("{} showing up on {} does not belong to {}",
new Object[] { sourceIP, p, subnet });
return;
}
HostNodeConnector requestor = null;
- if (isUnicastMAC(sourceMAC)) {
- // TODO For not this is only OPENFLOW but we need to fix this
- if (p.getType().equals(
- NodeConnector.NodeConnectorIDType.OPENFLOW)) {
- try {
- requestor = new HostNodeConnector(sourceMAC, sourceIP, p, subnet
- .getVlan());
- } catch (ConstructionException e) {
- return;
- }
- /*
- * Learn host from the received ARP REQ/REPLY, inform
- * Host Tracker
- */
- logger.debug("Inform Host tracker of new host {}", requestor.getNetworkAddress());
- synchronized (this.hostListener) {
- for (IfHostListener listener : this.hostListener) {
- listener.hostListener(requestor);
- }
- }
+ if (NetUtils.isUnicastMACAddr(sourceMAC) && p.getNode() != null) {
+ try {
+ requestor = new HostNodeConnector(sourceMAC, sourceIP, p, subnet.getVlan());
+ } catch (ConstructionException e) {
+ log.debug("Received ARP packet with invalid MAC: {}", sourceMAC);
+ return;
+ }
+ /*
+ * Learn host from the received ARP REQ/REPLY, inform Host Tracker
+ */
+ log.trace("Inform Host tracker of new host {}", requestor.getNetworkAddress());
+ for (IfHostListener listener : this.hostListeners) {
+ listener.hostListener(requestor);
}
- }
- /*
- * Gratuitous ARP. If there are hosts (in arpRequestors) waiting for the
- * ARP reply for this sourceIP, it's time to generate the reply and it
- * to these hosts
- */
- if (sourceIP.equals(targetIP)) {
- generateAndSendReply(sourceIP, sourceMAC);
- return;
}
/*
- * ARP Reply. If there are hosts (in arpRequesttors) waiting for the ARP
- * reply for this sourceIP, it's time to generate the reply and it to
- * these hosts
+ * OpCode != request -> ARP Reply. If there are hosts (in
+ * arpRequestors) waiting for the ARP reply for this sourceIP, it's
+ * time to generate the reply and send it to these hosts.
+ *
+ * If sourceIP==targetIP, it is a Gratuitous ARP. If there are hosts (in
+ * arpRequestors) waiting for the ARP reply for this sourceIP, it's time
+ * to generate the reply and send it to these hosts
*/
- if (pkt.getOpCode() != ARP.REQUEST) {
- generateAndSendReply(sourceIP, sourceMAC);
+
+ if (pkt.getOpCode() != ARP.REQUEST || sourceIP.equals(targetIP)) {
+ // Raise a reply event so that any waiting requestors will be sent a reply
+ // the true value indicates we should generate replies to requestors across the cluster
+ log.trace("Received ARP reply packet from {}, reply to all requestors.", sourceIP);
+ arpRequestReplyEvent.put(new ARPReply(sourceIP, sourceMAC), true);
return;
}
* the IP address defined in the subnet as source address
*/
/*
- * Send ARP reply if target IP is gateway IP
+ * If target IP is gateway IP, Send ARP reply
*/
if ((targetIP.equals(subnet.getNetworkAddress()))
- && (isBroadcastMAC(targetMAC) || Arrays.equals(targetMAC,
- getControllerMAC()))) {
- sendARPReply(p, getControllerMAC(), targetIP, pkt
- .getSenderHardwareAddress(), sourceIP);
+ && (NetUtils.isBroadcastMACAddr(targetMAC) || Arrays.equals(targetMAC, getControllerMAC()))) {
+ if (connectionManager.isLocal(p.getNode())){
+ if (log.isTraceEnabled()){
+ log.trace("Received local ARP req. for default gateway. Replying with controller MAC: {}", getControllerMAC());
+ }
+ sendARPReply(p, getControllerMAC(), targetIP, pkt.getSenderHardwareAddress(), sourceIP);
+ } else {
+ log.trace("Received non-local ARP req. for default gateway. Raising reply event");
+ arpRequestReplyEvent.put(
+ new ARPReply(p, targetIP, getControllerMAC(), sourceIP, pkt.getSenderHardwareAddress()), false);
+ }
return;
}
- /*
- * unknown host, initiate ARP request
- */
+
HostNodeConnector host = hostTracker.hostQuery(targetIP);
+ // unknown host, initiate ARP request
if (host == null) {
// add the requestor to the list so that we can replay the reply
// when the host responds
if (requestor != null) {
- Set<HostNodeConnector> requestorSet = arpRequestors
- .get(targetIP);
- if ((requestorSet == null) || requestorSet.isEmpty()) {
- requestorSet = new HashSet<HostNodeConnector>();
- countDownTimers.put(targetIP, (short) 2); // set max timeout
- // to 2sec
+ Set<HostNodeConnector> requestorSet = arpRequestors.get(targetIP);
+ if (requestorSet == null) {
+ requestorSet = Collections.newSetFromMap(new ConcurrentHashMap<HostNodeConnector, Boolean>());
+ arpRequestors.put(targetIP, requestorSet);
}
requestorSet.add(requestor);
- arpRequestors.put(targetIP, requestorSet);
+ countDownTimers.put(targetIP, (short) 2); // reset timeout to 2sec
}
- sendBcastARPRequest(targetIP, subnet);
- return;
- }
- /*
- * Known target host, send ARP REPLY
- * make sure that targetMAC matches the host's MAC if it is not broadcastMAC
- */
- if (isBroadcastMAC(targetMAC)
- || Arrays.equals(host.getDataLayerAddressBytes(), targetMAC)) {
- sendARPReply(p, host.getDataLayerAddressBytes(), host
- .getNetworkAddress(), pkt.getSenderHardwareAddress(),
- sourceIP);
- return;
+ //Raise a bcast request event, all controllers need to send one
+ log.trace("Sending a bcast ARP request for {}", targetIP);
+ arpRequestReplyEvent.put(new ARPRequest(targetIP, subnet), false);
+
} else {
/*
- * target target MAC has been changed. For now, discard it.
- * TODO: We may need to send unicast ARP REQUEST on behalf of the
- * target back to the sender to trigger the sender to
- * update its table
+ * Target host known (across the cluster), send ARP REPLY make sure that targetMAC
+ * matches the host's MAC if it is not broadcastMAC
*/
- return;
+ if (NetUtils.isBroadcastMACAddr(targetMAC) || Arrays.equals(host.getDataLayerAddressBytes(), targetMAC)) {
+ log.trace("Received ARP req. for known host {}, sending reply...", targetIP);
+ if (connectionManager.isLocal(p.getNode())) {
+ sendARPReply(p,
+ host.getDataLayerAddressBytes(),
+ host.getNetworkAddress(),
+ pkt.getSenderHardwareAddress(),
+ sourceIP);
+ } else {
+ arpRequestReplyEvent.put(new ARPReply(
+ p,
+ host.getNetworkAddress(),
+ host.getDataLayerAddressBytes(),
+ sourceIP,
+ pkt.getSenderHardwareAddress()), false);
+ }
+ } else {
+ /*
+ * Target MAC has been changed. For now, discard it.
+ * TODO: We may need to send unicast ARP REQUEST on behalf of
+ * the target back to the sender to trigger the sender to update
+ * its table
+ */
+ }
}
}
if (subnet.isFlatLayer2()) {
nodeConnectors = new HashSet<NodeConnector>();
for (Node n : this.switchManager.getNodes()) {
- nodeConnectors.addAll(this.switchManager
- .getUpNodeConnectors(n));
+ nodeConnectors.addAll(this.switchManager.getUpNodeConnectors(n));
}
} else {
nodeConnectors = subnet.getNodeConnectors();
}
+
for (NodeConnector p : nodeConnectors) {
- if (topologyManager.isInternal(p)) {
+
+ //fiter out any non-local or internal ports
+ if (! connectionManager.isLocal(p.getNode()) || topologyManager.isInternal(p)) {
continue;
}
ARP arp = new ARP();
byte[] senderIP = subnet.getNetworkAddress().getAddress();
- byte[] targetIPB = targetIP.getAddress();
+ byte[] targetIPByte = targetIP.getAddress();
arp.setHardwareType(ARP.HW_TYPE_ETHERNET)
.setProtocolType(EtherTypes.IPv4.shortValue())
.setHardwareAddressLength((byte) 6)
.setOpCode(ARP.REQUEST)
.setSenderHardwareAddress(getControllerMAC())
.setSenderProtocolAddress(senderIP)
- .setTargetHardwareAddress(new byte[] { (byte) 0, (byte) 0,
- (byte) 0, (byte) 0,
- (byte) 0, (byte) 0 })
- .setTargetProtocolAddress(targetIPB);
+ .setTargetHardwareAddress(
+ new byte[] { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 })
+ .setTargetProtocolAddress(targetIPByte);
Ethernet ethernet = new Ethernet();
ethernet.setSourceMACAddress(getControllerMAC())
- .setDestinationMACAddress(new byte[] { (byte) -1,
+ .setDestinationMACAddress(new byte[] {(byte) -1,
(byte) -1,
(byte) -1,
(byte) -1,
* The sender MAC is the controller's MAC
*/
protected void sendUcastARPRequest(HostNodeConnector host, Subnet subnet) {
- //Long swID = host.getnodeconnectornodeId();
- //Short portID = host.getnodeconnectorportId();
- //Node n = NodeCreator.createOFNode(swID);
- Node n = host.getnodeconnectorNode();
- if (n == null) {
- logger.error("cannot send UcastARP because cannot extract node "
- + "from HostNodeConnector: {}", host);
- return;
- }
+
NodeConnector outPort = host.getnodeConnector();
if (outPort == null) {
- logger.error("cannot send UcastARP because cannot extract "
- + "outPort from HostNodeConnector: {}", host);
+ log.error("Failed sending UcastARP because cannot extract output port from Host: {}", host);
return;
}
byte[] targetIP = host.getNetworkAddress().getAddress();
byte[] targetMAC = host.getDataLayerAddressBytes();
ARP arp = new ARP();
- arp.setHardwareType(ARP.HW_TYPE_ETHERNET).setProtocolType(
- EtherTypes.IPv4.shortValue())
- .setHardwareAddressLength((byte) 6).setProtocolAddressLength(
- (byte) 4).setOpCode(ARP.REQUEST)
- .setSenderHardwareAddress(getControllerMAC())
- .setSenderProtocolAddress(senderIP).setTargetHardwareAddress(
- targetMAC).setTargetProtocolAddress(targetIP);
+ arp.setHardwareType(ARP.HW_TYPE_ETHERNET)
+ .setProtocolType(EtherTypes.IPv4.shortValue())
+ .setHardwareAddressLength((byte) 6)
+ .setProtocolAddressLength((byte) 4)
+ .setOpCode(ARP.REQUEST)
+ .setSenderHardwareAddress(getControllerMAC())
+ .setSenderProtocolAddress(senderIP)
+ .setTargetHardwareAddress(targetMAC)
+ .setTargetProtocolAddress(targetIP);
Ethernet ethernet = new Ethernet();
ethernet.setSourceMACAddress(getControllerMAC())
- .setDestinationMACAddress(targetMAC).setEtherType(
- EtherTypes.ARP.shortValue()).setPayload(arp);
+ .setDestinationMACAddress(targetMAC)
+ .setEtherType(EtherTypes.ARP.shortValue())
+ .setPayload(arp);
RawPacket destPkt = this.dataPacketService.encodeDataPacket(ethernet);
destPkt.setOutgoingNodeConnector(outPort);
}
public void find(InetAddress networkAddress) {
- logger.debug("Received find IP {}", networkAddress);
+ log.trace("Received find IP {}", networkAddress);
Subnet subnet = null;
if (switchManager != null) {
subnet = switchManager.getSubnetByNetworkAddress(networkAddress);
}
if (subnet == null) {
- logger.debug("can't find subnet matching IP {}", networkAddress);
+ log.debug("Can't find subnet matching IP {}", networkAddress);
return;
}
- logger.debug("found subnet {}", subnet);
- // send a broadcast ARP Request to this interface
- sendBcastARPRequest(networkAddress, subnet);
+ // send a broadcast ARP Request to this IP
+ arpRequestReplyEvent.put(new ARPRequest(networkAddress, subnet), false);
}
/*
* Probe the host by sending a unicast ARP Request to the host
*/
public void probe(HostNodeConnector host) {
- logger.debug("Received probe host {}", host);
+ log.trace("Received probe host {}", host);
Subnet subnet = null;
if (switchManager != null) {
.getNetworkAddress());
}
if (subnet == null) {
- logger.debug("can't find subnet matching {}", host
- .getNetworkAddress());
+ log.debug("can't find subnet matching {}", host.getNetworkAddress());
return;
}
- sendUcastARPRequest(host, subnet);
+
+ if (connectionManager.isLocal(host.getnodeconnectorNode())){
+ log.trace("Send a ucast ARP req. to: {}", host);
+ sendUcastARPRequest(host, subnet);
+ } else {
+ log.trace("Raise a ucast ARP req. event to: {}", host);
+ arpRequestReplyEvent.put(new ARPRequest(host, subnet), false);
+ }
}
/*
* Need to discover it by sending a Broadcast ARP Request
*/
protected void handlePuntedIPPacket(IPv4 pkt, NodeConnector p) {
- InetAddress dIP = null;
- try {
- dIP = InetAddress.getByAddress(NetUtils.intToByteArray4(pkt
- .getDestinationAddress()));
- } catch (UnknownHostException e1) {
- return;
+
+ InetAddress dIP = NetUtils.getInetAddress(pkt.getDestinationAddress());
+ if (dIP == null) {
+ return;
}
Subnet subnet = null;
subnet = switchManager.getSubnetByNetworkAddress(dIP);
}
if (subnet == null) {
- logger.debug("can't find subnet matching {}, drop packet", dIP);
+ log.debug("Can't find subnet matching {}, drop packet", dIP);
return;
}
- logger.debug("Found {} matching {}", subnet, dIP);
+ log.trace("Punted IP pkt from {}, sending bcast ARP event...", dIP);
/*
- * unknown destination host, initiate ARP request
+ * unknown destination host, initiate bcast ARP request
*/
- sendBcastARPRequest(dIP, subnet);
+ arpRequestReplyEvent.put(new ARPRequest(dIP, subnet), false);
return;
}
void init() {
arpRequestors = new ConcurrentHashMap<InetAddress, Set<HostNodeConnector>>();
countDownTimers = new ConcurrentHashMap<InetAddress, Short>();
+
+ allocateCaches();
+ retrieveCaches();
+ }
+
+ @SuppressWarnings({ "unchecked", "deprecation" })
+ private void retrieveCaches() {
+ ConcurrentMap<?,?> map;
+
+ if (this.clusterContainerService == null){
+ log.error("Cluster service unavailable, can't retieve ARPHandler caches!");
+ return;
+ }
+
+ map = clusterContainerService.getCache(ARP_EVENT_CACHE_NAME);
+ if (map != null){
+ this.arpRequestReplyEvent = (ConcurrentMap<ARPEvent, Boolean>) map;
+ } else {
+ log.error("Cache allocation failed for {}", ARP_EVENT_CACHE_NAME);
+ }
}
+ @SuppressWarnings("deprecation")
+ private void allocateCaches() {
+ if (clusterContainerService == null){
+ nonClusterObjectCreate();
+ log.error("Clustering service unavailable. Allocated non-cluster caches for ARPHandler.");
+ return;
+ }
+
+ try{
+ clusterContainerService.createCache(ARP_EVENT_CACHE_NAME,
+ EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
+ } catch (CacheConfigException e){
+ log.error("ARPHandler cache configuration invalid!");
+ } catch (CacheExistException e){
+ log.debug("ARPHandler cache exists, skipped allocation.");
+ }
+
+ }
+
+ private void nonClusterObjectCreate(){
+ arpRequestReplyEvent = new ConcurrentHashMap<ARPEvent, Boolean>();
+ }
/**
* Function called by the dependency manager when at least one
* dependency become unsatisfied or when the component is shutting
* followed by a "destroy ()" calls
*
*/
- void stop() {
+ void stop(){
+ }
+
+ void stopping() {
cancelPeriodicTimer();
}
void setSwitchManager(ISwitchManager s) {
- logger.debug("SwitchManager set");
+ log.debug("SwitchManager service set.");
this.switchManager = s;
}
void unsetSwitchManager(ISwitchManager s) {
if (this.switchManager == s) {
- logger.debug("SwitchManager removed!");
+ log.debug("SwitchManager service UNset.");
this.switchManager = null;
}
}
if (inPkt == null) {
return PacketResult.IGNORED;
}
- logger
- .trace("Received a frame of size: {}",
- inPkt.getPacketData().length);
+ log.trace("Received a frame of size: {}", inPkt.getPacketData().length);
Packet formattedPak = this.dataPacketService.decodeDataPacket(inPkt);
if (formattedPak instanceof Ethernet) {
Object nextPak = formattedPak.getPayload();
if (nextPak instanceof IPv4) {
- handlePuntedIPPacket((IPv4) nextPak, inPkt
- .getIncomingNodeConnector());
- logger.trace("Handled IP packet");
- }
- if (nextPak instanceof ARP) {
+ log.trace("Handle IP packet: {}", formattedPak);
+ handlePuntedIPPacket((IPv4) nextPak, inPkt.getIncomingNodeConnector());
+ } else if (nextPak instanceof ARP) {
+ log.trace("Handle ARP packet: {}", formattedPak);
handleARPPacket((Ethernet) formattedPak, (ARP) nextPak, inPkt
.getIncomingNodeConnector());
- logger.trace("Handled ARP packet");
}
}
return PacketResult.IGNORED;
private void startPeriodicTimer() {
this.periodicTimer = new Timer("ArpHandler Periodic Timer");
this.periodicTimer.scheduleAtFixedRate(new TimerTask() {
+ @SuppressWarnings("deprecation")
@Override
public void run() {
Set<InetAddress> targetIPs = countDownTimers.keySet();
countDownTimers.replace(t, tick);
}
}
- for (InetAddress t : expiredTargets) {
- countDownTimers.remove(t);
- // remove the requestor(s) who have been waited for the ARP
+ for (InetAddress tIP : expiredTargets) {
+ countDownTimers.remove(tIP);
+ // Remove the requestor(s) who have been waiting for the ARP
// reply from this target for more than 1sec
- arpRequestors.remove(t);
- logger.debug("{} didn't respond to ARP request", t);
+ arpRequestors.remove(tIP);
+ log.debug("ARP reply was not received from {}", tIP);
+ }
+
+ // Clean up ARP event cache
+ try {
+ if (clusterContainerService.amICoordinator() && ! arpRequestReplyEvent.isEmpty()){
+ arpRequestReplyEvent.clear();
+ }
+ } catch (Exception e){
+ log.warn("ARPHandler: A cluster member failed to clear event cache.");
}
}
}, 0, 1000);
}
countDownTimers.remove(sourceIP);
for (HostNodeConnector host : hosts) {
- logger.debug(
- "Sending ARP Reply with src {}/{}, target {}/{}",
- new Object[] { sourceMAC, sourceIP,
- host.getDataLayerAddressBytes(),
- host.getNetworkAddress() });
- sendARPReply(host.getnodeConnector(), sourceMAC, sourceIP,
- host.getDataLayerAddressBytes(), host.getNetworkAddress());
+ log.trace("Sending ARP Reply with src {}/{}, target {}/{}",
+ new Object[] { sourceMAC, sourceIP, host.getDataLayerAddressBytes(), host.getNetworkAddress() });
+
+ if (connectionManager.isLocal(host.getnodeconnectorNode())){
+ sendARPReply(host.getnodeConnector(),
+ sourceMAC,
+ sourceIP,
+ host.getDataLayerAddressBytes(),
+ host.getNetworkAddress());
+ } else {
+ arpRequestReplyEvent.put(
+ new ARPReply(
+ host.getnodeConnector(),
+ sourceIP,
+ sourceMAC,
+ host.getNetworkAddress(),
+ host.getDataLayerAddressBytes()), false);
+ }
+ }
+ }
+
+
+ @Override
+ public void entryUpdated(ARPEvent key, Boolean new_value, String cacheName, boolean originLocal) {
+ if (key instanceof ARPRequest) {
+ ARPRequest req = (ARPRequest) key;
+ // If broadcast request
+ if (req.getHost() == null) {
+ sendBcastARPRequest(req.getTargetIP(), req.getSubnet());
+
+ //If unicast and local, send reply
+ } else if (connectionManager.isLocal(req.getHost().getnodeconnectorNode())) {
+ sendUcastARPRequest(req.getHost(), req.getSubnet());
+ }
+ } else if (key instanceof ARPReply) {
+ ARPReply rep = (ARPReply) key;
+ // New reply received by controller, notify all awaiting requestors across the cluster
+ if (new_value) {
+ generateAndSendReply(rep.getTargetIP(), rep.getTargetMac());
+
+ // Otherwise, a specific reply. If local, send out.
+ } else if (connectionManager.isLocal(rep.getPort().getNode())) {
+ sendARPReply(rep.getPort(),
+ rep.getSourceMac(),
+ rep.getSourceIP(),
+ rep.getTargetMac(),
+ rep.getTargetIP());
+ }
}
}
+
+ @Override
+ public void entryCreated(ARPEvent key, String cacheName, boolean originLocal) {
+ // nothing to do
+ }
+ @Override
+ public void entryDeleted(ARPEvent key, String cacheName, boolean originLocal) {
+ // nothing to do
+ }
}
</plugins>
</build>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager.implementation</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection.implementation</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>topologymanager</artifactId>
*
* We can't recover from condition 3 above
*/
- private final
ArrayList<ARPPending> failedARPReqList = new ArrayList<HostTracker.ARPPending>();
+ private final List<ARPPending> failedARPReqList = new ArrayList<HostTracker.ARPPending>();
public HostTracker() {
}
}
}
- private void
edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
+ private void
debugEdgeUpdate(Edge e, UpdateType type, Set<Property> props) {
Long srcNid = null;
Short srcPort = null;
Long dstNid = null;
}
if (!srcType.equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
- logger.error("For now we cannot handle updates for " + "non-openflow nodes");
+ logger.debug("For now we cannot handle updates for non-openflow nodes");
return;
}
}
if (!dstType.equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
- logger.error("For now we cannot handle updates for " + "non-openflow nodes");
+ logger.debug("For now we cannot handle updates for non-openflow nodes");
return;
}
@Override
public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
- for (int i = 0; i < topoedgeupdateList.size(); i++) {
- Edge e = topoedgeupdateList.get(i).getEdge();
- Set<Property> p = topoedgeupdateList.get(i).getProperty();
- UpdateType type = topoedgeupdateList.get(i).getUpdateType();
- edgeUpdate(e, type, p);
+ if (logger.isDebugEnabled()) {
+ for (TopoEdgeUpdate topoEdgeUpdate : topoedgeupdateList) {
+ Edge e = topoEdgeUpdate.getEdge();
+ Set<Property> p = topoEdgeUpdate.getProperty();
+ UpdateType type = topoEdgeUpdate.getUpdateType();
+
+ debugEdgeUpdate(e, type, p);
+ }
}
}
-/*\r
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-\r
-package org.opendaylight.controller.hosttracker.internal;\r
-\r
-import java.net.InetAddress;\r
-import java.net.UnknownHostException;\r
-import java.util.ArrayList;\r
-import java.util.HashSet;\r
-import java.util.Iterator;\r
-import java.util.List;\r
-import java.util.Map;\r
-import java.util.Set;\r
-import java.util.Map.Entry;\r
-\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-import org.osgi.framework.ServiceReference;\r
-import org.osgi.framework.Bundle;\r
-import javax.inject.Inject;\r
-\r
-import org.eclipse.osgi.framework.console.CommandProvider;\r
-import org.junit.Assert;\r
-import org.junit.Test;\r
-import org.junit.Before;\r
-import org.junit.After;\r
-import org.junit.runner.RunWith;\r
-import org.opendaylight.controller.sal.core.Node;\r
-import org.opendaylight.controller.sal.core.NodeConnector;\r
-import org.opendaylight.controller.sal.core.UpdateType;\r
-import org.opendaylight.controller.sal.utils.NodeConnectorCreator;\r
-import org.opendaylight.controller.sal.utils.NodeCreator;\r
-import org.opendaylight.controller.sal.utils.Status;\r
-//import org.opendaylight.controller.hosttracker.*;\r
-import org.opendaylight.controller.hosttracker.IfIptoHost;\r
-import org.opendaylight.controller.hosttracker.IfHostListener;\r
-import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;\r
-import org.opendaylight.controller.switchmanager.IInventoryListener;\r
-import org.opendaylight.controller.switchmanager.ISwitchManager;\r
-import org.opendaylight.controller.switchmanager.ISwitchManagerAware;\r
-import org.opendaylight.controller.topologymanager.ITopologyManagerAware;\r
-\r
-import org.ops4j.pax.exam.junit.PaxExam;\r
-import org.ops4j.pax.exam.util.Filter;\r
-import org.osgi.framework.BundleContext;\r
-import static org.junit.Assert.*;\r
-import org.ops4j.pax.exam.junit.Configuration;\r
-import static org.ops4j.pax.exam.CoreOptions.*;\r
-\r
-import org.ops4j.pax.exam.Option;\r
-import org.ops4j.pax.exam.util.PathUtils;\r
-import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;\r
-import org.ops4j.pax.exam.spi.reactors.PerClass;\r
-\r
-@RunWith(PaxExam.class)\r
-public class HostTrackerIT {\r
- private Logger log = LoggerFactory.getLogger(HostTrackerIT.class);\r
- // get the OSGI bundle context\r
- @Inject\r
- private BundleContext bc;\r
-\r
- private IfIptoHost hosttracker = null;\r
- private ISwitchManagerAware switchManagerAware = null;\r
- private IInventoryListener invtoryListener = null;\r
- private IfHostListener hostListener = null;\r
- private ITopologyManagerAware topologyManagerAware = null;\r
-\r
- // Configure the OSGi container\r
- @Configuration\r
- public Option[] config() {\r
- return options(\r
- //\r
- systemProperty("logback.configurationFile").value(\r
- "file:" + PathUtils.getBaseDir()\r
- + "/src/test/resources/logback.xml"),\r
- // To start OSGi console for inspection remotely\r
- systemProperty("osgi.console").value("2401"),\r
- // Set the systemPackages (used by clustering)\r
- systemPackages("sun.reflect", "sun.reflect.misc", "sun.misc"),\r
- // List framework bundles\r
- mavenBundle("equinoxSDK381", "org.eclipse.equinox.console",\r
- "1.0.0.v20120522-1841"),\r
- mavenBundle("equinoxSDK381", "org.eclipse.equinox.util",\r
- "1.0.400.v20120522-2049"),\r
- mavenBundle("equinoxSDK381", "org.eclipse.osgi.services",\r
- "3.3.100.v20120522-1822"),\r
- mavenBundle("equinoxSDK381", "org.eclipse.equinox.ds",\r
- "1.4.0.v20120522-1841"),\r
- mavenBundle("equinoxSDK381", "org.apache.felix.gogo.command",\r
- "0.8.0.v201108120515"),\r
- mavenBundle("equinoxSDK381", "org.apache.felix.gogo.runtime",\r
- "0.8.0.v201108120515"),\r
- mavenBundle("equinoxSDK381", "org.apache.felix.gogo.shell",\r
- "0.8.0.v201110170705"),\r
- // List logger bundles\r
- mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(),\r
- mavenBundle("org.slf4j", "log4j-over-slf4j")\r
- .versionAsInProject(),\r
- mavenBundle("ch.qos.logback", "logback-core")\r
- .versionAsInProject(),\r
- mavenBundle("ch.qos.logback", "logback-classic")\r
- .versionAsInProject(),\r
-\r
- // List all the bundles on which the test case depends\r
- mavenBundle("org.opendaylight.controller", "sal")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller", "sal.implementation")\r
- .versionAsInProject(),\r
-\r
- // needed by statisticsmanager\r
- mavenBundle("org.opendaylight.controller", "containermanager")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller",\r
- "containermanager.implementation").versionAsInProject(),\r
-\r
- mavenBundle("org.opendaylight.controller",\r
- "clustering.services").versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller", "clustering.stub")\r
- .versionAsInProject(),\r
-\r
- // needed by forwardingrulesmanager\r
- mavenBundle("org.opendaylight.controller", "switchmanager")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller",\r
- "switchmanager.implementation").versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller", "configuration")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller",\r
- "configuration.implementation").versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller", "hosttracker")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller",\r
- "hosttracker.implementation").versionAsInProject(),\r
-\r
- // needed by hosttracker\r
- mavenBundle("org.opendaylight.controller", "topologymanager")\r
- .versionAsInProject(),\r
- mavenBundle("org.opendaylight.controller", "arphandler")\r
- .versionAsInProject(),\r
-\r
- mavenBundle("org.jboss.spec.javax.transaction",\r
- "jboss-transaction-api_1.1_spec").versionAsInProject(),\r
- mavenBundle("org.apache.commons", "commons-lang3")\r
- .versionAsInProject(),\r
- mavenBundle("org.apache.felix",\r
- "org.apache.felix.dependencymanager")\r
- .versionAsInProject(), junitBundles());\r
- }\r
-\r
- private String stateToString(int state) {\r
- switch (state) {\r
- case Bundle.ACTIVE:\r
- return "ACTIVE";\r
- case Bundle.INSTALLED:\r
- return "INSTALLED";\r
- case Bundle.RESOLVED:\r
- return "RESOLVED";\r
- case Bundle.UNINSTALLED:\r
- return "UNINSTALLED";\r
- default:\r
- return "Not CONVERTED";\r
- }\r
- }\r
-\r
- @Before\r
- public void areWeReady() {\r
- assertNotNull(bc);\r
- boolean debugit = false;\r
- Bundle b[] = bc.getBundles();\r
- for (int i = 0; i < b.length; i++) {\r
- int state = b[i].getState();\r
- if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {\r
- log.debug("Bundle:" + b[i].getSymbolicName() + " state:"\r
- + stateToString(state));\r
- debugit = true;\r
- }\r
- }\r
- if (debugit) {\r
- log.debug("Do some debugging because some bundle is "\r
- + "unresolved");\r
- }\r
-\r
- // Assert if true, if false we are good to go!\r
- assertFalse(debugit);\r
-\r
- // Now lets create a hosttracker for testing purpose\r
- ServiceReference s = bc.getServiceReference(IfIptoHost.class.getName());\r
- if (s != null) {\r
- this.hosttracker = (IfIptoHost) bc.getService(s);\r
- this.switchManagerAware = (ISwitchManagerAware) this.hosttracker;\r
- this.invtoryListener = (IInventoryListener) this.hosttracker;\r
- this.hostListener = (IfHostListener) this.hosttracker;\r
- this.topologyManagerAware = (ITopologyManagerAware) this.hosttracker;\r
- }\r
-\r
- // If StatisticsManager is null, cannot run tests.\r
- assertNotNull(this.hosttracker);\r
- }\r
-\r
- @Test\r
- public void testStaticHost() throws UnknownHostException {\r
- String ip;\r
-\r
- assertNotNull(this.hosttracker);\r
-\r
- // create one node and two node connectors\r
- Node node1 = NodeCreator.createOFNode(1L);\r
- NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 1, node1);\r
- NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 2, node1);\r
-\r
- // test addStaticHost(), store into inactive host DB\r
- Status st = this.hosttracker.addStaticHost("192.168.0.8",\r
- "11:22:33:44:55:66", nc1_1, "0");\r
- Assert.assertTrue(st.isSuccess());\r
- st = this.hosttracker.addStaticHost("192.168.0.13",\r
- "11:22:33:44:55:77", nc1_2, "0");\r
- Assert.assertTrue(st.isSuccess());\r
-\r
- // check inactive DB\r
- Iterator<HostNodeConnector> hnci = this.hosttracker\r
- .getInactiveStaticHosts().iterator();\r
- while (hnci.hasNext()) {\r
- ip = hnci.next().getNetworkAddressAsString();\r
- Assert.assertTrue(ip.equals("192.168.0.8")\r
- || ip.equals("192.168.0.13"));\r
- }\r
-\r
- // check active host DB\r
- hnci = this.hosttracker.getActiveStaticHosts().iterator();\r
- Assert.assertFalse(hnci.hasNext());\r
-\r
- // test removeStaticHost()\r
- st = this.hosttracker.removeStaticHost("192.168.0.8");\r
- Assert.assertTrue(st.isSuccess());\r
-\r
- hnci = this.hosttracker.getInactiveStaticHosts().iterator();\r
- while (hnci.hasNext()) {\r
- ip = hnci.next().getNetworkAddressAsString();\r
- Assert.assertTrue(ip.equals("192.168.0.13"));\r
- }\r
- }\r
-\r
- @Test\r
- public void testNotifyNodeConnector() throws UnknownHostException {\r
- String ip;\r
-\r
- assertNotNull(this.invtoryListener);\r
-\r
- // create one node and two node connectors\r
- Node node1 = NodeCreator.createOFNode(1L);\r
- NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 1, node1);\r
- NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 2, node1);\r
-\r
- // test addStaticHost(), put into inactive host DB if not verifiable\r
- Status st = this.hosttracker.addStaticHost("192.168.0.8",\r
- "11:22:33:44:55:66", nc1_1, "0");\r
- st = this.hosttracker.addStaticHost("192.168.0.13",\r
- "11:22:33:44:55:77", nc1_2, "0");\r
-\r
- this.invtoryListener.notifyNodeConnector(nc1_1, UpdateType.ADDED, null);\r
-\r
- // check all host list\r
- Iterator<HostNodeConnector> hnci = this.hosttracker.getAllHosts()\r
- .iterator();\r
- while (hnci.hasNext()) {\r
- ip = hnci.next().getNetworkAddressAsString();\r
- Assert.assertTrue(ip.equals("192.168.0.8"));\r
- }\r
-\r
- // check active host DB\r
- hnci = this.hosttracker.getActiveStaticHosts().iterator();\r
- while (hnci.hasNext()) {\r
- ip = hnci.next().getNetworkAddressAsString();\r
- Assert.assertTrue(ip.equals("192.168.0.8"));\r
- }\r
-\r
- // check inactive host DB\r
- hnci = this.hosttracker.getInactiveStaticHosts().iterator();\r
- while (hnci.hasNext()) {\r
- ip = hnci.next().getNetworkAddressAsString();\r
- Assert.assertTrue(ip.equals("192.168.0.13"));\r
- }\r
- }\r
-\r
- @Test\r
- public void testHostFind() throws UnknownHostException {\r
-\r
- assertNotNull(this.invtoryListener);\r
-\r
- // create one node and two node connectors\r
- Node node1 = NodeCreator.createOFNode(1L);\r
- NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 1, node1);\r
- NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector(\r
- (short) 2, node1);\r
-\r
- // test addStaticHost(), put into inactive host DB if not verifiable\r
- Status st = this.hosttracker.addStaticHost("192.168.0.8",\r
- "11:22:33:44:55:66", nc1_1, "0");\r
- st = this.hosttracker.addStaticHost("192.168.0.13",\r
- "11:22:33:44:55:77", nc1_2, "0");\r
-\r
- HostNodeConnector hnc_1 = this.hosttracker.hostFind(InetAddress\r
- .getByName("192.168.0.8"));\r
- assertNull(hnc_1);\r
-\r
- this.invtoryListener.notifyNodeConnector(nc1_1, UpdateType.ADDED, null);\r
-\r
- hnc_1 = this.hosttracker.hostFind(InetAddress.getByName("192.168.0.8"));\r
- assertNotNull(hnc_1);\r
-\r
- }\r
-\r
-}\r
+/*
+ * 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.hosttracker.internal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.ops4j.pax.exam.CoreOptions.junitBundles;
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import static org.ops4j.pax.exam.CoreOptions.options;
+import static org.ops4j.pax.exam.CoreOptions.systemPackages;
+import static org.ops4j.pax.exam.CoreOptions.systemProperty;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Iterator;
+
+import javax.inject.Inject;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.hosttracker.IfIptoHost;
+import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.controller.sal.core.NodeConnector;
+import org.opendaylight.controller.sal.core.UpdateType;
+import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
+import org.opendaylight.controller.sal.utils.NodeCreator;
+import org.opendaylight.controller.sal.utils.Status;
+import org.opendaylight.controller.switchmanager.IInventoryListener;
+import org.ops4j.pax.exam.Option;
+import org.ops4j.pax.exam.junit.Configuration;
+import org.ops4j.pax.exam.junit.PaxExam;
+import org.ops4j.pax.exam.util.PathUtils;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+//import org.opendaylight.controller.hosttracker.*;
+
+@RunWith(PaxExam.class)
+public class HostTrackerIT {
+ private Logger log = LoggerFactory.getLogger(HostTrackerIT.class);
+ // get the OSGI bundle context
+ @Inject
+ private BundleContext bc;
+
+ private IfIptoHost hosttracker = null;
+ private IInventoryListener invtoryListener = null;
+ // Configure the OSGi container
+ @Configuration
+ public Option[] config() {
+ return options(
+
+ //
+ systemProperty("logback.configurationFile").value(
+ "file:" + PathUtils.getBaseDir() + "/src/test/resources/logback.xml"),
+ // To start OSGi console for inspection remotely
+ systemProperty("osgi.console").value("2401"),
+ // Set the systemPackages (used by clustering)
+ systemPackages("sun.reflect", "sun.reflect.misc", "sun.misc"),
+ // List framework bundles
+ mavenBundle("equinoxSDK381", "org.eclipse.equinox.console", "1.0.0.v20120522-1841"),
+ mavenBundle("equinoxSDK381", "org.eclipse.equinox.util", "1.0.400.v20120522-2049"),
+ mavenBundle("equinoxSDK381", "org.eclipse.osgi.services","3.3.100.v20120522-1822"),
+ mavenBundle("equinoxSDK381", "org.eclipse.equinox.ds", "1.4.0.v20120522-1841"),
+ mavenBundle("equinoxSDK381", "org.apache.felix.gogo.command", "0.8.0.v201108120515"),
+ mavenBundle("equinoxSDK381", "org.apache.felix.gogo.runtime", "0.8.0.v201108120515"),
+ mavenBundle("equinoxSDK381", "org.apache.felix.gogo.shell", "0.8.0.v201110170705"),
+ // List logger bundles
+ mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(),
+ mavenBundle("org.slf4j", "log4j-over-slf4j").versionAsInProject(),
+ mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(),
+ mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(),
+
+ // List all the bundles on which the test case depends
+ mavenBundle("org.opendaylight.controller", "sal").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "sal.implementation").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "sal.connection").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "sal.connection.implementation").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "connectionmanager").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "connectionmanager.implementation").versionAsInProject(),
+
+ // needed by statisticsmanager
+ mavenBundle("org.opendaylight.controller", "containermanager").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "containermanager.implementation").versionAsInProject(),
+
+ mavenBundle("org.opendaylight.controller", "clustering.services").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "clustering.stub").versionAsInProject(),
+
+ // needed by forwardingrulesmanager
+ mavenBundle("org.opendaylight.controller", "switchmanager").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "switchmanager.implementation").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "configuration").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "configuration.implementation").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "hosttracker").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "hosttracker.implementation").versionAsInProject(),
+
+ // needed by hosttracker
+ mavenBundle("org.opendaylight.controller", "topologymanager").versionAsInProject(),
+ mavenBundle("org.opendaylight.controller", "arphandler").versionAsInProject(),
+
+ mavenBundle("org.jboss.spec.javax.transaction", "jboss-transaction-api_1.1_spec").versionAsInProject(),
+ mavenBundle("org.apache.commons", "commons-lang3").versionAsInProject(),
+ mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager").versionAsInProject(),
+ junitBundles());
+ }
+
+ private String stateToString(int state) {
+ switch (state) {
+ case Bundle.ACTIVE:
+ return "ACTIVE";
+ case Bundle.INSTALLED:
+ return "INSTALLED";
+ case Bundle.RESOLVED:
+ return "RESOLVED";
+ case Bundle.UNINSTALLED:
+ return "UNINSTALLED";
+ default:
+ return "Not CONVERTED";
+ }
+ }
+
+ @Before
+ public void areWeReady() {
+ assertNotNull(bc);
+ boolean debugit = false;
+ Bundle b[] = bc.getBundles();
+ for (int i = 0; i < b.length; i++) {
+ int state = b[i].getState();
+ if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
+ log.debug("Bundle:" + b[i].getSymbolicName() + " state:" + stateToString(state));
+ debugit = true;
+ }
+ }
+ if (debugit) {
+ log.debug("Do some debugging because some bundle is " + "unresolved");
+ }
+
+ // Assert if true, if false we are good to go!
+ assertFalse(debugit);
+
+ // Now lets create a hosttracker for testing purpose
+ ServiceReference s = bc.getServiceReference(IfIptoHost.class.getName());
+ if (s != null) {
+ this.hosttracker = (IfIptoHost) bc.getService(s);
+ this.invtoryListener = (IInventoryListener) this.hosttracker;
+ }
+
+ // If StatisticsManager is null, cannot run tests.
+ assertNotNull(this.hosttracker);
+ }
+
+ @Test
+ public void testStaticHost() throws UnknownHostException {
+ String ip;
+
+ assertNotNull(this.hosttracker);
+
+ // create one node and two node connectors
+ Node node1 = NodeCreator.createOFNode(1L);
+ NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector((short) 1, node1);
+ NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector((short) 2, node1);
+
+ // test addStaticHost(), store into inactive host DB
+ Status st = this.hosttracker.addStaticHost("192.168.0.8", "11:22:33:44:55:66", nc1_1, "0");
+ Assert.assertTrue(st.isSuccess());
+ st = this.hosttracker.addStaticHost("192.168.0.13", "11:22:33:44:55:77", nc1_2, "0");
+ Assert.assertTrue(st.isSuccess());
+
+ // check inactive DB
+ Iterator<HostNodeConnector> hnci = this.hosttracker.getInactiveStaticHosts().iterator();
+ while (hnci.hasNext()) {
+ ip = hnci.next().getNetworkAddressAsString();
+ Assert.assertTrue(ip.equals("192.168.0.8") || ip.equals("192.168.0.13"));
+ }
+
+ // check active host DB
+ hnci = this.hosttracker.getActiveStaticHosts().iterator();
+ Assert.assertFalse(hnci.hasNext());
+
+ // test removeStaticHost()
+ st = this.hosttracker.removeStaticHost("192.168.0.8");
+ Assert.assertTrue(st.isSuccess());
+
+ hnci = this.hosttracker.getInactiveStaticHosts().iterator();
+ while (hnci.hasNext()) {
+ ip = hnci.next().getNetworkAddressAsString();
+ Assert.assertTrue(ip.equals("192.168.0.13"));
+ }
+ }
+
+ @Test
+ public void testNotifyNodeConnector() throws UnknownHostException {
+ String ip;
+
+ assertNotNull(this.invtoryListener);
+
+ // create one node and two node connectors
+ Node node1 = NodeCreator.createOFNode(1L);
+ NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector((short) 1, node1);
+ NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector((short) 2, node1);
+
+ // test addStaticHost(), put into inactive host DB if not verifiable
+ Status st = this.hosttracker.addStaticHost("192.168.0.8", "11:22:33:44:55:66", nc1_1, "0");
+ st = this.hosttracker.addStaticHost("192.168.0.13", "11:22:33:44:55:77", nc1_2, "0");
+
+ this.invtoryListener.notifyNodeConnector(nc1_1, UpdateType.ADDED, null);
+
+ // check all host list
+ Iterator<HostNodeConnector> hnci = this.hosttracker.getAllHosts().iterator();
+ while (hnci.hasNext()) {
+ ip = hnci.next().getNetworkAddressAsString();
+ Assert.assertTrue(ip.equals("192.168.0.8"));
+ }
+
+ // check active host DB
+ hnci = this.hosttracker.getActiveStaticHosts().iterator();
+ while (hnci.hasNext()) {
+ ip = hnci.next().getNetworkAddressAsString();
+ Assert.assertTrue(ip.equals("192.168.0.8"));
+ }
+
+ // check inactive host DB
+ hnci = this.hosttracker.getInactiveStaticHosts().iterator();
+ while (hnci.hasNext()) {
+ ip = hnci.next().getNetworkAddressAsString();
+ Assert.assertTrue(ip.equals("192.168.0.13"));
+ }
+ }
+
+ @Test
+ public void testHostFind() throws UnknownHostException {
+
+ assertNotNull(this.invtoryListener);
+
+ // create one node and two node connectors
+ Node node1 = NodeCreator.createOFNode(1L);
+ NodeConnector nc1_1 = NodeConnectorCreator.createOFNodeConnector((short) 1, node1);
+ NodeConnector nc1_2 = NodeConnectorCreator.createOFNodeConnector((short) 2, node1);
+
+ // test addStaticHost(), put into inactive host DB if not verifiable
+ Status st = this.hosttracker.addStaticHost("192.168.0.8", "11:22:33:44:55:66", nc1_1, "0");
+ st = this.hosttracker.addStaticHost("192.168.0.13", "11:22:33:44:55:77", nc1_2, "0");
+
+ HostNodeConnector hnc_1 = this.hosttracker.hostFind(InetAddress.getByName("192.168.0.8"));
+ assertNull(hnc_1);
+
+ this.invtoryListener.notifyNodeConnector(nc1_1, UpdateType.ADDED, null);
+
+ hnc_1 = this.hosttracker.hostFind(InetAddress.getByName("192.168.0.8"));
+ assertNotNull(hnc_1);
+
+ }
+
+}
</pluginRepository>
</pluginRepositories>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager.implementation</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
<artifactId>sal.implementation</artifactId>
<version>0.4.0-SNAPSHOT</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection.implementation</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>forwarding.staticrouting</artifactId>
mavenBundle("org.opendaylight.controller", "security", "0.4.0-SNAPSHOT").noStart(),
mavenBundle("org.opendaylight.controller", "sal", "0.5.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "sal.implementation", "0.4.0-SNAPSHOT"),
+ mavenBundle("org.opendaylight.controller", "sal.connection", "0.1.0-SNAPSHOT"),
+ mavenBundle("org.opendaylight.controller", "sal.connection.implementation", "0.1.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "switchmanager", "0.5.0-SNAPSHOT"),
+ mavenBundle("org.opendaylight.controller", "connectionmanager", "0.1.0-SNAPSHOT"),
+ mavenBundle("org.opendaylight.controller", "connectionmanager.implementation", "0.1.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "switchmanager.implementation", "0.4.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "forwardingrulesmanager", "0.4.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "forwardingrulesmanager.implementation", "0.4.0-SNAPSHOT"),
return false;
}
+ /**
+ * Returns true if the MAC address is a unicast MAC address and false
+ * otherwise.
+ *
+ * @param MACAddress
+ * @return
+ */
+ public static boolean isUnicastMACAddr(byte[] MACAddress) {
+ if (MACAddress.length == MACAddrLengthInBytes) {
+ return (MACAddress[0] & 1) == 0;
+ }
+ return false;
+ }
/**
* Returns true if the MAC address is a multicast MAC address and false
Code Review / controller.git / commitdiff