<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
# of.messageResponseTimer=2000
# The switch liveness timeout value (default 60500 msec)
# of.switchLivenessTimeout=60500
+# The flow statistics polling interval in second (default 10 sec)
+# of.flowStatsPollInterval=10
+# The port statistics polling interval in second (default 5 sec)
+# of.portStatsPollInterval=5
+# The description statistics polling interval in second (default 60 sec)
+# of.descStatsPollInterval=60
# The maximum number of asynchronous messages can be sent before sending a Barrier Request (default 100)
# of.barrierMessagePriorCount=100
# The interval which determines how often the discovery packets should be sent (default 300 sec)
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
mavenBundle("ch.qos.logback", "logback-classic", "1.0.9"),
// List all the bundles on which the test case depends
mavenBundle("org.opendaylight.controller", "sal",
- "0.4.0-SNAPSHOT"),
+ "0.5.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller",
"sal.implementation", "0.4.0-SNAPSHOT"),
Assert.assertTrue(stat.getCode().equals(StatusCode.NOTACCEPTABLE));
}
-}
\ No newline at end of file
+}
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.4.0-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
</dependency>\r
</dependencies>\r
</project>\r
<Import-Package>
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
+ org.opendaylight.controller.sal.topology,
org.opendaylight.controller.hosttracker,
org.opendaylight.controller.topologymanager,
org.opendaylight.controller.sal.packet.address,
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import java.util.concurrent.Future;
import org.apache.felix.dm.Component;
-import org.apache.taglibs.standard.lang.jstl.DivideOperator;
import org.opendaylight.controller.clustering.services.CacheConfigException;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.packet.address.DataLinkAddress;
import org.opendaylight.controller.sal.packet.address.EthernetAddress;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.HexEncode;
import org.opendaylight.controller.sal.utils.NodeCreator;
import org.slf4j.LoggerFactory;
/**
- * @file HostTracker.java
- * This class tracks the location of IP Hosts as to which Switch, Port, VLAN, they are
- * connected to, as well as their MAC address. This is done dynamically as well as statically.
- * The dynamic mechanism consists of listening to ARP messages as well sending ARP requests.
- * Static mechanism consists of Northbound APIs to add or remove the hosts from the local
- * database. ARP aging is also implemented to age out dynamically learned hosts. Interface
- * methods are provided for other applications to
- * 1. Query the local database for a single host
- * 2. Get a list of all hosts
- * 3. Get notification if a host is learned/added or removed the database
+ * @file HostTracker.java This class tracks the location of IP Hosts as to which
+ * Switch, Port, VLAN, they are connected to, as well as their MAC
+ * address. This is done dynamically as well as statically. The dynamic
+ * mechanism consists of listening to ARP messages as well sending ARP
+ * requests. Static mechanism consists of Northbound APIs to add or remove
+ * the hosts from the local database. ARP aging is also implemented to age
+ * out dynamically learned hosts. Interface methods are provided for other
+ * applications to 1. Query the local database for a single host 2. Get a
+ * list of all hosts 3. Get notification if a host is learned/added or
+ * removed the database
*/
public class HostTracker implements IfIptoHost, IfHostListener,
.getLogger(HostTracker.class);
private IHostFinder hostFinder;
private ConcurrentMap<InetAddress, HostNodeConnector> hostsDB;
- /* Following is a list of hosts which have been requested by NB APIs to be added,
- * but either the switch or the port is not sup, so they will be added here until
- * both come up
+ /*
+ * Following is a list of hosts which have been requested by NB APIs to be
+ * added, but either the switch or the port is not sup, so they will be
+ * added here until both come up
*/
private ConcurrentMap<NodeConnector, HostNodeConnector> inactiveStaticHosts;
private Set<IfNewHostNotify> newHostNotify = Collections
}
}
- //This list contains the hosts for which ARP requests are being sent periodically
+ // This list contains the hosts for which ARP requests are being sent
+ // periodically
private List<ARPPending> ARPPendingList = new ArrayList<HostTracker.ARPPending>();
/*
- * This list below contains the hosts which were initially in ARPPendingList above,
- * but ARP response didn't come from there hosts after multiple attempts over 8
- * seconds. The assumption is that the response didn't come back due to one of the
- * following possibilities:
- * 1. The L3 interface wasn't created for this host in the controller. This would
- * cause arphandler not to know where to send the ARP
- * 2. The host facing port is down
- * 3. The IP host doesn't exist or is not responding to ARP requests
- *
- * Conditions 1 and 2 above can be recovered if ARP is sent when the relevant L3
- * interface is added or the port facing host comes up. Whenever L3 interface is
- * added or host facing port comes up, ARP will be sent to hosts in this list.
- *
+ * This list below contains the hosts which were initially in ARPPendingList
+ * above, but ARP response didn't come from there hosts after multiple
+ * attempts over 8 seconds. The assumption is that the response didn't come
+ * back due to one of the following possibilities: 1. The L3 interface
+ * wasn't created for this host in the controller. This would cause
+ * arphandler not to know where to send the ARP 2. The host facing port is
+ * down 3. The IP host doesn't exist or is not responding to ARP requests
+ *
+ * Conditions 1 and 2 above can be recovered if ARP is sent when the
+ * relevant L3 interface is added or the port facing host comes up. Whenever
+ * L3 interface is added or host facing port comes up, ARP will be sent to
+ * hosts in this list.
+ *
* We can't recover from condition 3 above
*/
private ArrayList<ARPPending> failedARPReqList = new ArrayList<HostTracker.ARPPending>();
}
@SuppressWarnings("deprecation")
- private void allocateCache() {
+ private void allocateCache() {
if (this.clusterContainerService == null) {
- logger
- .error("un-initialized clusterContainerService, can't create cache");
+ logger.error("un-initialized clusterContainerService, can't create cache");
return;
}
logger.debug("Creating Cache for HostTracker");
try {
- this.clusterContainerService.createCache("hostTrackerAH", EnumSet
- .of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
- this.clusterContainerService.createCache("hostTrackerIH", EnumSet
- .of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
+ this.clusterContainerService.createCache("hostTrackerAH",
+ EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
+ this.clusterContainerService.createCache("hostTrackerIH",
+ EnumSet.of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
} catch (CacheConfigException cce) {
- logger
- .error("Cache couldn't be created for HostTracker - check cache mode");
+ logger.error("Cache couldn't be created for HostTracker - check cache mode");
} catch (CacheExistException cce) {
- logger
- .error("Cache for HostTracker already exists, destroy and recreate");
+ logger.error("Cache for HostTracker already exists, destroy and recreate");
}
logger.debug("Cache successfully created for HostTracker");
}
@SuppressWarnings({ "unchecked", "deprecation" })
private void retrieveCache() {
if (this.clusterContainerService == null) {
- logger
- .error("un-initialized clusterContainerService, can't retrieve cache");
+ logger.error("un-initialized clusterContainerService, can't retrieve cache");
return;
}
logger.debug("Retrieving cache for HostTrackerAH");
}
@SuppressWarnings("deprecation")
- private void destroyCache() {
+ private void destroyCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
return;
for (Entry<NodeConnector, HostNodeConnector> entry : inactiveStaticHosts
.entrySet()) {
if (entry.getValue().equalsByIP(networkAddress)) {
- logger
- .debug(
- "getHostFromInactiveDB(): Inactive Host found for IP:{} ",
- networkAddress.getHostAddress());
+ logger.debug(
+ "getHostFromInactiveDB(): Inactive Host found for IP:{} ",
+ networkAddress.getHostAddress());
return entry;
}
}
public HostNodeConnector hostFind(InetAddress networkAddress) {
/*
- * Sometimes at boot with containers configured in the startup
- * we hit this path (from TIF) when hostFinder has not been set yet
- * Caller already handles the null return
+ * Sometimes at boot with containers configured in the startup we hit
+ * this path (from TIF) when hostFinder has not been set yet Caller
+ * already handles the null return
*/
if (hostFinder == null) {
HostNodeConnector host = hostQuery(networkAddress);
if (host != null) {
- logger.debug("hostFind(): Host found for IP: {}", networkAddress
- .getHostAddress());
+ logger.debug("hostFind(): Host found for IP: {}",
+ networkAddress.getHostAddress());
return host;
}
/* host is not found, initiate a discovery */
hostFinder.find(networkAddress);
/* Also add this host to ARPPending List for any potential retries */
AddtoARPPendingList(networkAddress);
- logger
- .debug(
- "hostFind(): Host Not Found for IP: {}, Inititated Host Discovery ...",
- networkAddress.getHostAddress());
+ logger.debug(
+ "hostFind(): Host Not Found for IP: {}, Inititated Host Discovery ...",
+ networkAddress.getHostAddress());
return null;
}
arphost.setHostIP(networkAddr);
arphost.setSent_count((short) 1);
ARPPendingList.add(arphost);
- logger.debug("Host Added to ARPPending List, IP: {}", networkAddr
- .toString());
+ logger.debug("Host Added to ARPPending List, IP: {}",
+ networkAddr.toString());
}
private void removePendingARPFromList(int index) {
if (index >= ARPPendingList.size()) {
- logger
- .warn(
- "removePendingARPFromList(): index greater than the List. Size:{}, Index:{}",
- ARPPendingList.size(), index);
+ logger.warn(
+ "removePendingARPFromList(): index greater than the List. Size:{}, Index:{}",
+ ARPPendingList.size(), index);
return;
}
ARPPending arphost = ARPPendingList.remove(index);
for (int i = 0; i < ARPPendingList.size(); i++) {
arphost = ARPPendingList.get(i);
if (arphost.getHostIP().equals(networkAddr)) {
- /* An ARP was sent for this host. The address is learned,
- * remove the request
+ /*
+ * An ARP was sent for this host. The address is learned, remove
+ * the request
*/
removePendingARPFromList(i);
logger.debug("Host Removed from ARPPending List, IP: {}",
for (int i = 0; i < failedARPReqList.size(); i++) {
arphost = failedARPReqList.get(i);
if (arphost.getHostIP().equals(networkAddr)) {
- /* An ARP was sent for this host. The address is learned,
- * remove the request
+ /*
+ * An ARP was sent for this host. The address is learned, remove
+ * the request
*/
failedARPReqList.remove(i);
logger.debug("Host Removed from FailedARPReqList List, IP: {}",
private void learnNewHost(HostNodeConnector host) {
host.initArpSendCountDown();
hostsDB.put(host.getNetworkAddress(), host);
- logger.debug("New Host Learned: MAC: {} IP: {}", HexEncode
- .bytesToHexString(host.getDataLayerAddressBytes()), host
- .getNetworkAddress().getHostAddress());
+ logger.debug("New Host Learned: MAC: {} IP: {}",
+ HexEncode.bytesToHexString(host.getDataLayerAddressBytes()),
+ host.getNetworkAddress().getHostAddress());
}
// Remove known Host
.getHostAddress());
hostsDB.remove(key);
} else {
- logger
- .error(
- "removeKnownHost(): Host for IP address {} not found in hostsDB",
- key.getHostAddress());
+ logger.error(
+ "removeKnownHost(): Host for IP address {} not found in hostsDB",
+ key.getHostAddress());
}
}
/* Check for Host Move case */
if (hostMoved(host)) {
/*
- * Host has been moved from one location (switch,port, MAC, or VLAN).
- * Remove the existing host with its previous location parameters,
- * inform the applications, and add it as a new Host
+ * Host has been moved from one location (switch,port, MAC, or
+ * VLAN). Remove the existing host with its previous location
+ * parameters, inform the applications, and add it as a new Host
*/
HostNodeConnector removedHost = hostsDB.get(host
.getNetworkAddress());
new NotifyHostThread(host).start();
}
- // Notify whoever is interested that a new host was learned (dynamically or statically)
+ // Notify whoever is interested that a new host was learned (dynamically or
+ // statically)
private void notifyHostLearnedOrRemoved(HostNodeConnector host, boolean add) {
// Update listeners if any
if (newHostNotify != null) {
}
}
} else {
- logger
- .error("notifyHostLearnedOrRemoved(): New host notify is null");
+ logger.error("notifyHostLearnedOrRemoved(): New host notify is null");
}
- // Topology update is for some reason outside of listeners registry logic
+ // Topology update is for some reason outside of listeners registry
+ // logic
Node node = host.getnodeconnectorNode();
Host h = null;
NodeConnector p = host.getnodeConnector();
try {
- DataLinkAddress dla = new EthernetAddress(host
- .getDataLayerAddressBytes());
- h = new org.opendaylight.controller.sal.core.Host(dla, host
- .getNetworkAddress());
+ DataLinkAddress dla = new EthernetAddress(
+ host.getDataLayerAddressBytes());
+ h = new org.opendaylight.controller.sal.core.Host(dla,
+ host.getNetworkAddress());
} catch (ConstructionException ce) {
p = null;
h = null;
switchManager.setNodeProp(node, tier);
topologyManager.updateHostLink(p, h, UpdateType.ADDED, null);
/*
- * This is a temporary fix for Cisco Live's Hadoop Demonstration.
- * The concept of Tiering must be revisited based on other application requirements
- * and the design might warrant a separate module (as it involves tracking the topology/
- * host changes & updating the Tiering numbers in an effective manner).
+ * This is a temporary fix for Cisco Live's Hadoop
+ * Demonstration. The concept of Tiering must be revisited based
+ * on other application requirements and the design might
+ * warrant a separate module (as it involves tracking the
+ * topology/ host changes & updating the Tiering numbers in an
+ * effective manner).
*/
updateSwitchTiers(node, 1);
/*
- * The following 2 lines are added for testing purposes.
- * We can remove it once the North-Bound APIs are available for testing.
-
- ArrayList<ArrayList<String>> hierarchies = getHostNetworkHierarchy(host.getNetworkAddress());
- logHierarchies(hierarchies);
+ * The following 2 lines are added for testing purposes. We can
+ * remove it once the North-Bound APIs are available for
+ * testing.
+ *
+ * ArrayList<ArrayList<String>> hierarchies =
+ * getHostNetworkHierarchy(host.getNetworkAddress());
+ * logHierarchies(hierarchies);
*/
} else {
- // No need to reset the tiering if no other hosts are currently connected
- // If this switch was discovered to be an access switch, it still is even if the host is down
+ // No need to reset the tiering if no other hosts are currently
+ // connected
+ // If this switch was discovered to be an access switch, it
+ // still is even if the host is down
Tier tier = new Tier(0);
switchManager.setNodeProp(node, tier);
topologyManager.updateHostLink(p, h, UpdateType.REMOVED, null);
}
/**
- * When a new Host is learnt by the hosttracker module, it places the directly connected Node
- * in Tier-1 & using this function, updates the Tier value for all other Nodes in the network
- * hierarchy.
- *
- * This is a recursive function and it takes care of updating the Tier value for all the connected
- * and eligible Nodes.
- *
- * @param n Node that represents one of the Vertex in the Topology Graph.
- * @param currentTier The Tier on which n belongs
+ * When a new Host is learnt by the hosttracker module, it places the
+ * directly connected Node in Tier-1 & using this function, updates the Tier
+ * value for all other Nodes in the network hierarchy.
+ *
+ * This is a recursive function and it takes care of updating the Tier value
+ * for all the connected and eligible Nodes.
+ *
+ * @param n
+ * Node that represents one of the Vertex in the Topology Graph.
+ * @param currentTier
+ * The Tier on which n belongs
*/
private void updateSwitchTiers(Node n, int currentTier) {
Map<Node, Set<Edge>> ndlinks = topologyManager.getNodeEdges();
}
ArrayList<Node> needsVisiting = new ArrayList<Node>();
for (Edge lt : links) {
- if (!lt.getHeadNodeConnector().getType().equals(
- NodeConnector.NodeConnectorIDType.OPENFLOW)) {
+ if (!lt.getHeadNodeConnector().getType()
+ .equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
// We don't want to work on Node that are not openflow
// for now
continue;
}
/**
- * Internal convenience routine to check the eligibility of a Switch for a Tier update.
- * Any Node with Tier=0 or a Tier value that is greater than the new Tier Value is eligible
- * for the update.
- *
- * @param n Node for which the Tier update eligibility is checked
- * @param tier new Tier Value
+ * Internal convenience routine to check the eligibility of a Switch for a
+ * Tier update. Any Node with Tier=0 or a Tier value that is greater than
+ * the new Tier Value is eligible for the update.
+ *
+ * @param n
+ * Node for which the Tier update eligibility is checked
+ * @param tier
+ * new Tier Value
* @return <code>true</code> if the Node is eligible for Tier Update
* <code>false</code> otherwise
*/
}
/**
- * Internal convenience routine to clear all the Tier values to 0.
- * This cleanup is performed during cases such as Topology Change where the existing Tier values
- * might become incorrect
+ * Internal convenience routine to clear all the Tier values to 0. This
+ * cleanup is performed during cases such as Topology Change where the
+ * existing Tier values might become incorrect
*/
private void clearTiers() {
Set<Node> nodes = null;
}
/**
- * getHostNetworkHierarchy is the Back-end routine for the North-Bound API that returns
- * the Network Hierarchy for a given Host. This API is typically used by applications like
- * Hadoop for Rack Awareness functionality.
- *
- * @param hostAddress IP-Address of the host/node.
- * @return Network Hierarchies represented by an Array of Array (of Switch-Ids as String).
+ * getHostNetworkHierarchy is the Back-end routine for the North-Bound API
+ * that returns the Network Hierarchy for a given Host. This API is
+ * typically used by applications like Hadoop for Rack Awareness
+ * functionality.
+ *
+ * @param hostAddress
+ * IP-Address of the host/node.
+ * @return Network Hierarchies represented by an Array of Array (of
+ * Switch-Ids as String).
*/
public List<List<String>> getHostNetworkHierarchy(InetAddress hostAddress) {
HostNodeConnector host = hostQuery(hostAddress);
}
/**
- * dpidToHostNameHack is a hack function for Cisco Live Hadoop Demo.
- * Mininet is used as the network for Hadoop Demos & in order to give a meaningful
- * rack-awareness switch names, the DPID is organized in ASCII Characters and
- * retrieved as string.
- *
- * @param dpid Switch DataPath Id
+ * dpidToHostNameHack is a hack function for Cisco Live Hadoop Demo. Mininet
+ * is used as the network for Hadoop Demos & in order to give a meaningful
+ * rack-awareness switch names, the DPID is organized in ASCII Characters
+ * and retrieved as string.
+ *
+ * @param dpid
+ * Switch DataPath Id
* @return Ascii String represented by the DPID.
*/
private String dpidToHostNameHack(long dpid) {
/**
* A convenient recursive routine to obtain the Hierarchy of Switches.
- *
- * @param node Current Node in the Recursive routine.
- * @param currHierarchy Array of Nodes that make this hierarchy on which the Current Switch belong
- * @param fullHierarchy Array of multiple Hierarchies that represent a given host.
+ *
+ * @param node
+ * Current Node in the Recursive routine.
+ * @param currHierarchy
+ * Array of Nodes that make this hierarchy on which the Current
+ * Switch belong
+ * @param fullHierarchy
+ * Array of multiple Hierarchies that represent a given host.
*/
@SuppressWarnings("unchecked")
private void updateCurrentHierarchy(Node node,
ArrayList<String> currHierarchy, List<List<String>> fullHierarchy) {
- //currHierarchy.add(String.format("%x", currSw.getId()));
+ // currHierarchy.add(String.format("%x", currSw.getId()));
currHierarchy.add(dpidToHostNameHack((Long) node.getID()));
ArrayList<String> currHierarchyClone = (ArrayList<String>) currHierarchy
- .clone(); //Shallow copy as required
+ .clone(); // Shallow copy as required
Map<Node, Set<Edge>> ndlinks = topologyManager.getNodeEdges();
if (ndlinks == null) {
- logger
- .debug(
- "updateCurrentHierarchy(): topologyManager returned null ndlinks for node: {}",
- node);
+ logger.debug(
+ "updateCurrentHierarchy(): topologyManager returned null ndlinks for node: {}",
+ node);
return;
}
Node n = NodeCreator.createOFNode((Long) node.getID());
return;
}
for (Edge lt : links) {
- if (!lt.getHeadNodeConnector().getType().equals(
- NodeConnector.NodeConnectorIDType.OPENFLOW)) {
+ if (!lt.getHeadNodeConnector().getType()
+ .equals(NodeConnector.NodeConnectorIDType.OPENFLOW)) {
// We don't want to work on Node that are not openflow
// for now
continue;
ArrayList<String> buildHierarchy = currHierarchy;
if (currHierarchy.size() > currHierarchyClone.size()) {
buildHierarchy = (ArrayList<String>) currHierarchyClone
- .clone(); //Shallow copy as required
+ .clone(); // Shallow copy as required
fullHierarchy.add(buildHierarchy);
}
updateCurrentHierarchy(dstNode, buildHierarchy, fullHierarchy);
}
}
- @Override
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
+ private void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
Long srcNid = null;
Short srcPort = null;
Long dstNid = null;
// At this point we know we got an openflow update, so
// lets fill everything accordingly.
- srcNid = (Long) e.getTailNodeConnector().getNode()
- .getID();
+ srcNid = (Long) e.getTailNodeConnector().getNode().getID();
srcPort = (Short) e.getTailNodeConnector().getID();
- dstNid = (Long) e.getHeadNodeConnector().getNode()
- .getID();
+ dstNid = (Long) e.getHeadNodeConnector().getNode().getID();
dstPort = (Short) e.getHeadNodeConnector().getID();
// Now lets update the added flag
}
}
- logger.debug("HostTracker Topology linkUpdate handling src:{}[port {}] dst:{}[port {}] added: {}",
- new Object[] { srcNid, srcPort, dstNid, dstPort, added });
+ logger.debug(
+ "HostTracker Topology linkUpdate handling src:{}[port {}] dst:{}[port {}] added: {}",
+ new Object[] { srcNid, srcPort, dstNid, dstPort, added });
clearTiers();
for (Entry<InetAddress, HostNodeConnector> entry : hostsDB.entrySet()) {
HostNodeConnector host = entry.getValue();
}
}
+ @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);
+ }
+ }
+
public void subnetNotify(Subnet sub, boolean add) {
logger.debug("Received subnet notification: {} add={}", sub, add);
if (add) {
for (int i = 0; i < ARPPendingList.size(); i++) {
arphost = ARPPendingList.get(i);
if (arphost.getSent_count() < switchManager.getHostRetryCount()) {
- /* No reply has been received of first ARP Req, send the next one */
+ /*
+ * No reply has been received of first ARP Req, send the
+ * next one
+ */
hostFinder.find(arphost.getHostIP());
arphost.sent_count++;
logger.debug("ARP Sent from ARPPending List, IP: {}",
arphost.getHostIP().getHostAddress());
} else if (arphost.getSent_count() >= switchManager
.getHostRetryCount()) {
- /* Two ARP requests have been sent without
- * receiving a reply, remove this from the
- * pending list
+ /*
+ * Two ARP requests have been sent without receiving a
+ * reply, remove this from the pending list
*/
removePendingARPFromList(i);
- logger
- .debug(
- "ARP reply not received after two attempts, removing from Pending List IP: {}",
- arphost.getHostIP().getHostAddress());
+ logger.debug(
+ "ARP reply not received after two attempts, removing from Pending List IP: {}",
+ arphost.getHostIP().getHostAddress());
/*
- * Add this host to a different list which will be processed on link
- * up events
+ * Add this host to a different list which will be processed
+ * on link up events
*/
logger.debug("Adding the host to FailedARPReqList IP: {}",
arphost.getHostIP().getHostAddress());
failedARPReqList.add(arphost);
} else {
- logger
- .error(
- "Inavlid arp_sent count for entery at index: {}",
- i);
+ logger.error(
+ "Inavlid arp_sent count for entery at index: {}", i);
}
}
}
}
if (hostsDB == null) {
/* hostsDB is not allocated yet */
- logger
- .error("ARPRefreshHandler(): hostsDB is not allocated yet:");
+ logger.error("ARPRefreshHandler(): hostsDB is not allocated yet:");
return;
}
for (Entry<InetAddress, HostNodeConnector> entry : hostsDB
if (arp_cntdown > switchManager.getHostRetryCount()) {
host.setArpSendCountDown(arp_cntdown);
} else if (arp_cntdown <= 0) {
- /* No ARP Reply received in last 2 minutes, remove this host and inform applications*/
+ /*
+ * No ARP Reply received in last 2 minutes, remove this host
+ * and inform applications
+ */
removeKnownHost(entry.getKey());
notifyHostLearnedOrRemoved(host, false);
} else if (arp_cntdown <= switchManager.getHostRetryCount()) {
- /* Use the services of arphandler to check if host is still there */
- logger.trace("ARP Probing ({}) for {}({})", new Object[] {
- arp_cntdown,
- host.getNetworkAddress().getHostAddress(),
- HexEncode.bytesToHexString(host
- .getDataLayerAddressBytes()) });
+ /*
+ * Use the services of arphandler to check if host is still
+ * there
+ */
+ logger.trace(
+ "ARP Probing ({}) for {}({})",
+ new Object[] {
+ arp_cntdown,
+ host.getNetworkAddress().getHostAddress(),
+ HexEncode.bytesToHexString(host
+ .getDataLayerAddressBytes()) });
host.setArpSendCountDown(arp_cntdown);
hostFinder.probe(host);
}
}
/**
- * Inform the controller IP to MAC binding of a host and its
- * connectivity to an openflow switch in terms of Node, port, and
- * VLAN.
- *
- * @param networkAddr IP address of the host
- * @param dataLayer Address MAC address of the host
- * @param nc NodeConnector to which host is connected
- * @param port Port of the switch to which host is connected
- * @param vlan Vlan of which this host is member of
- *
- * @return Status The status object as described in {@code Status}
- * indicating the result of this action.
+ * Inform the controller IP to MAC binding of a host and its connectivity to
+ * an openflow switch in terms of Node, port, and VLAN.
+ *
+ * @param networkAddr
+ * IP address of the host
+ * @param dataLayer
+ * Address MAC address of the host
+ * @param nc
+ * NodeConnector to which host is connected
+ * @param port
+ * Port of the switch to which host is connected
+ * @param vlan
+ * Vlan of which this host is member of
+ *
+ * @return Status The status object as described in {@code Status}
+ * indicating the result of this action.
*/
public Status addStaticHostReq(InetAddress networkAddr,
byte[] dataLayerAddress, NodeConnector nc, short vlan) {
if (dataLayerAddress.length != 6) {
- return new Status(StatusCode.BADREQUEST, "Invalid MAC address");
+ return new Status(StatusCode.BADREQUEST, "Invalid MAC address");
}
HostNodeConnector host = null;
try {
host = new HostNodeConnector(dataLayerAddress, networkAddr, nc,
- vlan);
+ vlan);
if (hostExists(host)) {
- // This host is already learned either via ARP or through a northbound request
+ // This host is already learned either via ARP or through a
+ // northbound request
HostNodeConnector transHost = hostsDB.get(networkAddr);
transHost.setStaticHost(true);
return new Status(StatusCode.SUCCESS, null);
}
host.setStaticHost(true);
/*
- * Before adding host, Check if the switch and the port have already come up
+ * Before adding host, Check if the switch and the port have already
+ * come up
*/
if (switchManager.isNodeConnectorEnabled(nc)) {
learnNewHost(host);
notifyHostLearnedOrRemoved(host, true);
} else {
inactiveStaticHosts.put(nc, host);
- logger
- .debug(
- "Switch or switchport is not up, adding host {} to inactive list",
- networkAddr.getHostName());
+ logger.debug(
+ "Switch or switchport is not up, adding host {} to inactive list",
+ networkAddr.getHostName());
}
return new Status(StatusCode.SUCCESS, null);
} catch (ConstructionException e) {
- return new Status(StatusCode.INTERNALERROR, "Host could not be created");
+ return new Status(StatusCode.INTERNALERROR,
+ "Host could not be created");
}
}
/**
- * Update the controller IP to MAC binding of a host and its
- * connectivity to an openflow switch in terms of
- * switch id, switch port, and VLAN.
- *
- * @param networkAddr IP address of the host
- * @param dataLayer Address MAC address of the host
- * @param nc NodeConnector to which host is connected
- * @param port Port of the switch to which host is connected
- * @param vlan Vlan of which this host is member of
- *
- * @return boolean true if the host was added successfully,
- * false otherwise
+ * Update the controller IP to MAC binding of a host and its connectivity to
+ * an openflow switch in terms of switch id, switch port, and VLAN.
+ *
+ * @param networkAddr
+ * IP address of the host
+ * @param dataLayer
+ * Address MAC address of the host
+ * @param nc
+ * NodeConnector to which host is connected
+ * @param port
+ * Port of the switch to which host is connected
+ * @param vlan
+ * Vlan of which this host is member of
+ *
+ * @return boolean true if the host was added successfully, false otherwise
*/
public boolean updateHostReq(InetAddress networkAddr,
- byte[] dataLayerAddress, NodeConnector nc,
- short vlan) {
+ byte[] dataLayerAddress, NodeConnector nc, short vlan) {
if (nc == null) {
return false;
}
HostNodeConnector host = null;
try {
host = new HostNodeConnector(dataLayerAddress, networkAddr, nc,
- vlan);
+ vlan);
if (!hostExists(host)) {
if ((inactiveStaticHosts.get(nc)) != null) {
inactiveStaticHosts.replace(nc, host);
/**
* Remove from the controller IP to MAC binding of a host and its
* connectivity to an openflow switch
- *
- * @param networkAddr IP address of the host
- *
- * @return boolean true if the host was removed successfully,
- * false otherwise
+ *
+ * @param networkAddr
+ * IP address of the host
+ *
+ * @return boolean true if the host was removed successfully, false
+ * otherwise
*/
public Status removeStaticHostReq(InetAddress networkAddress) {
if (host != null) {
// Validation check
if (!host.isStaticHost()) {
- return new Status(StatusCode.FORBIDDEN,
- "Host " + networkAddress.getHostName() +
- " is not static");
+ return new Status(StatusCode.FORBIDDEN, "Host "
+ + networkAddress.getHostName() + " is not static");
}
// Remove and notify
notifyHostLearnedOrRemoved(host, false);
host = entry.getValue();
// Validation check
if (!host.isStaticHost()) {
- return new Status(StatusCode.FORBIDDEN,
- "Host " + networkAddress.getHostName() +
- " is not static");
+ return new Status(StatusCode.FORBIDDEN, "Host "
+ + networkAddress.getHostName() + " is not static");
}
this.removeHostFromInactiveDB(networkAddress);
return new Status(StatusCode.SUCCESS, null);
switch (type) {
case REMOVED:
long sid = (Long) node.getID();
- logger.debug("Received removedSwitch for sw id {}", HexEncode
- .longToHexString(sid));
+ logger.debug("Received removedSwitch for sw id {}",
+ HexEncode.longToHexString(sid));
for (Entry<InetAddress, HostNodeConnector> entry : hostsDB
.entrySet()) {
HostNodeConnector host = entry.getValue();
@Override
public Status addStaticHost(String networkAddress, String dataLayerAddress,
- NodeConnector nc, String vlan) {
+ NodeConnector nc, String vlan) {
try {
InetAddress ip = InetAddress.getByName(networkAddress);
if (nc == null) {
- return new Status(StatusCode.BADREQUEST, "Invalid NodeId");
+ return new Status(StatusCode.BADREQUEST, "Invalid NodeId");
}
return addStaticHostReq(ip,
- HexEncode
- .bytesFromHexString(dataLayerAddress),
- nc,
+ HexEncode.bytesFromHexString(dataLayerAddress), nc,
Short.valueOf(vlan));
} catch (UnknownHostException e) {
- logger.error("",e);
+ logger.error("", e);
return new Status(StatusCode.BADREQUEST, "Invalid Address");
}
}
address = InetAddress.getByName(networkAddress);
return removeStaticHostReq(address);
} catch (UnknownHostException e) {
- logger.error("",e);
+ logger.error("", e);
return new Status(StatusCode.BADREQUEST, "Invalid Address");
}
}
/**
* Function called by the dependency manager when all the required
* dependencies are satisfied
- *
+ *
*/
void init(Component c) {
Dictionary<?, ?> props = c.getServiceProperties();
}
/**
- * Function called by the dependency manager when at least one
- * dependency become unsatisfied or when the component is shutting
- * down because for example bundle is being stopped.
- *
+ * Function called by the dependency manager when at least one dependency
+ * become unsatisfied or when the component is shutting down because for
+ * example bundle is being stopped.
+ *
*/
void destroy() {
destroyCache();
}
/**
- * Function called by dependency manager after "init ()" is called
- * and after the services provided by the class are registered in
- * the service registry
- *
+ * Function called by dependency manager after "init ()" is called and after
+ * the services provided by the class are registered in the service registry
+ *
*/
void start() {
}
/**
- * Function called by the dependency manager before the services
- * exported by the component are unregistered, this will be
- * followed by a "destroy ()" calls
- *
+ * Function called by the dependency manager before the services exported by
+ * the component are unregistered, this will be followed by a "destroy ()"
+ * calls
+ *
*/
void stop() {
}
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.4.0-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
\r
// List all the bundles on which the test case depends\r
mavenBundle("org.opendaylight.controller", "sal",\r
- "0.4.0-SNAPSHOT"),\r
+ "0.5.0-SNAPSHOT"),\r
mavenBundle("org.opendaylight.controller", "sal.implementation",\r
"0.4.0-SNAPSHOT"),\r
\r
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.codehaus.enunciate</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.thirdparty</groupId>
package org.opendaylight.controller.protocol_plugin.openflow;
/**
- * Wrapper of Interface class that provides inventory updates locally in the
- * protocol plugin
- *
- *
+ * Wrapper of Interface that provides inventory updates locally in the protocol
+ * plugin.
*/
public interface IInventoryShimExternalListener extends
IInventoryShimInternalListener {
import org.opendaylight.controller.sal.core.UpdateType;
/**
- * Interface class that provides inventory updates to inventory listeners
- * within the protocol plugin
- *
- *
+ * The Interface provides inventory updates to inventory listeners within the
+ * protocol plugin
*/
public interface IInventoryShimInternalListener {
/**
import org.opendaylight.controller.sal.core.UpdateType;
/**
- * Interface class that provides Edge updates to the topology listeners
- *
- *
+ * The Interface provides Edge updates to the topology listeners
*/
public interface ITopologyServiceShimListener {
/**
if (imp.equals(TopologyServiceShim.class)) {
c.setInterface(new String[] { IDiscoveryService.class.getName(),
IContainerListener.class.getName(),
- IRefreshInternalProvider.class.getName() }, null);
- c.add(createServiceDependency()
+ IRefreshInternalProvider.class.getName(),
+ IInventoryShimExternalListener.class.getName() }, null);
+ c.add(createServiceDependency()
.setService(ITopologyServiceShimListener.class)
.setCallbacks("setTopologyServiceShimListener",
"unsetTopologyServiceShimListener")
txRates = new HashMap<Long, Map<Short, TxRates>>(initialSize);
descriptionListeners = new HashSet<IStatisticsListener>();
+ configStatsPollIntervals();
+
// Initialize managed timers
statisticsTimer = new Timer();
statisticsTimerTask = new TimerTask() {
help.append("---OF Statistics Manager utilities---\n");
help.append("\t ofdumpstatsmgr - "
+ "Print Internal Stats Mgr db\n");
+ help.append("\t ofstatsmgrintervals <fP> <pP> <dP>(in seconds) - "
+ + "Set/Show flow/port/dedscription stats poll intervals\n");
return help.toString();
}
public void _ofstatsmgrintervals(CommandInterpreter ci) {
String flowStatsInterv = ci.nextArgument();
String portStatsInterv = ci.nextArgument();
+ String descStatsInterv = ci.nextArgument();
- if (flowStatsInterv == null || portStatsInterv == null) {
-
- ci.println("Usage: ostatsmgrintervals <fP> <pP> (in seconds)");
+ if (flowStatsInterv == null || portStatsInterv == null
+ || descStatsInterv == null) {
+ ci.println("Usage: ostatsmgrintervals <fP> <pP> <dP>(in seconds)");
ci.println("Current Values: fP=" + statisticsTickNumber + "s pP="
- + portTickNumber + "s");
+ + portTickNumber + "s dP=" + descriptionTickNumber + "s");
return;
}
- Short fP, pP;
+ Short fP, pP, dP;
try {
fP = Short.parseShort(flowStatsInterv);
pP = Short.parseShort(portStatsInterv);
+ dP = Short.parseShort(descStatsInterv);
} catch (Exception e) {
ci.println("Invalid format values: " + e.getMessage());
return;
}
- if (pP <= 1 || fP <= 1) {
- ci.println("Invalid values. fP and pP have to be greater than 1.");
+ if (pP <= 1 || fP <= 1 || dP <= 1) {
+ ci.println("Invalid values. fP, pP, dP have to be greater than 1.");
return;
}
statisticsTickNumber = fP;
portTickNumber = pP;
+ descriptionTickNumber = dP;
ci.println("New Values: fP=" + statisticsTickNumber + "s pP="
- + portTickNumber + "s");
+ + portTickNumber + "s dP=" + descriptionTickNumber + "s");
}
+ /**
+ * This method retrieves user configurations from config.ini and updates
+ * statisticsTickNumber/portTickNumber/descriptionTickNumber accordingly.
+ */
+ private void configStatsPollIntervals() {
+ String fsStr = System.getProperty("of.flowStatsPollInterval");
+ String psStr = System.getProperty("of.portStatsPollInterval");
+ String dsStr = System.getProperty("of.descStatsPollInterval");
+ Short fs, ps, ds;
+
+ if (fsStr != null) {
+ try {
+ fs = Short.parseShort(fsStr);
+ if (fs > 0) {
+ statisticsTickNumber = fs;
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ if (psStr != null) {
+ try {
+ ps = Short.parseShort(psStr);
+ if (ps > 0) {
+ portTickNumber = ps;
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ if (dsStr != null) {
+ try {
+ ds = Short.parseShort(dsStr);
+ if (ds > 0) {
+ descriptionTickNumber = ds;
+ }
+ } catch (Exception e) {
+ }
+ }
+ }
}
import org.apache.commons.lang3.tuple.Pair;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
+import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimExternalListener;
import org.opendaylight.controller.protocol_plugin.openflow.IOFStatisticsManager;
import org.opendaylight.controller.protocol_plugin.openflow.IRefreshInternalProvider;
import org.opendaylight.controller.protocol_plugin.openflow.ITopologyServiceShimListener;
import org.slf4j.LoggerFactory;
import org.opendaylight.controller.sal.core.Bandwidth;
+import org.opendaylight.controller.sal.core.Config;
import org.opendaylight.controller.sal.core.ContainerFlow;
import org.opendaylight.controller.sal.core.Edge;
import org.opendaylight.controller.sal.core.IContainerListener;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.core.Property;
+import org.opendaylight.controller.sal.core.State;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.discovery.IDiscoveryService;
import org.opendaylight.controller.sal.utils.GlobalConstants;
* container configurations.
*/
public class TopologyServiceShim implements IDiscoveryService,
- IContainerListener, CommandProvider, IRefreshInternalProvider {
+ IContainerListener, CommandProvider, IRefreshInternalProvider,
+ IInventoryShimExternalListener {
protected static final Logger logger = LoggerFactory
.getLogger(TopologyServiceShim.class);
private ConcurrentMap<String, ITopologyServiceShimListener> topologyServiceShimListeners = new ConcurrentHashMap<String, ITopologyServiceShimListener>();
logger.debug("Sent {} updates", i);
}
+ @Override
+ public void updateNode(Node node, UpdateType type, Set<Property> props) {
+ }
+
+ @Override
+ public void updateNodeConnector(NodeConnector nodeConnector,
+ UpdateType type, Set<Property> props) {
+ List<String> containers = new ArrayList<String>();
+ List<String> conList = this.containerMap.get(nodeConnector);
+
+ containers.add(GlobalConstants.DEFAULT.toString());
+ if (conList != null) {
+ containers.addAll(conList);
+ }
+
+ switch (type) {
+ case ADDED:
+ break;
+ case CHANGED:
+ if (props == null) {
+ break;
+ }
+
+ boolean rmEdge = false;
+ for (Property prop : props) {
+ if (((prop instanceof Config) && (((Config) prop).getValue() != Config.ADMIN_UP))
+ || ((prop instanceof State) && (((State) prop)
+ .getValue() != State.EDGE_UP))) {
+ /*
+ * If port admin down or link down, remove the edges
+ * associated with the port
+ */
+ rmEdge = true;
+ break;
+ }
+ }
+
+ if (rmEdge) {
+ for (String cName : containers) {
+ removeNodeConnector(cName, nodeConnector);
+ }
+ }
+ break;
+ case REMOVED:
+ for (String cName : containers) {
+ removeNodeConnector(cName, nodeConnector);
+ }
+ break;
+ default:
+ break;
+ }
+ }
}
package org.opendaylight.controller.protocol_plugin.openflow.internal;
import java.util.Dictionary;
+import java.util.List;
import java.util.Set;
+import java.util.ArrayList;
import org.apache.felix.dm.Component;
import org.opendaylight.controller.protocol_plugin.openflow.IRefreshInternalProvider;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.topology.IPluginInTopologyService;
import org.opendaylight.controller.sal.topology.IPluginOutTopologyService;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
public class TopologyServices implements ITopologyServiceShimListener,
IPluginInTopologyService {
@Override
public void edgeUpdate(Edge edge, UpdateType type, Set<Property> props) {
if (this.salTopoService != null) {
- this.salTopoService.edgeUpdate(edge, type, props);
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
+ TopoEdgeUpdate teu = new TopoEdgeUpdate(edge, props, type);
+ topoedgeupdateList.add(teu);
+ this.salTopoService.edgeUpdate(topoedgeupdateList);
}
}
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>junit</groupId>
org.slf4j,
org.opendaylight.controller.sal.routing,
org.opendaylight.controller.sal.core,
+ org.opendaylight.controller.sal.topology,
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.reader,
org.apache.commons.collections15,
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.reader.IReadService;
import org.opendaylight.controller.sal.routing.IListenRoutingUpdates;
+
import org.opendaylight.controller.sal.routing.IRouting;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.switchmanager.ISwitchManager;
import org.opendaylight.controller.topologymanager.ITopologyManager;
import org.opendaylight.controller.topologymanager.ITopologyManagerAware;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.ArrayList;
import java.util.Set;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
.getLogger(DijkstraImplementation.class);
private ConcurrentMap<Short, Graph<Node, Edge>> topologyBWAware;
private ConcurrentMap<Short, DijkstraShortestPath<Node, Edge>> sptBWAware;
- DijkstraShortestPath<Node, Edge> mtp; //Max Throughput Path
+ DijkstraShortestPath<Node, Edge> mtp; // Max Throughput Path
private Set<IListenRoutingUpdates> routingAware;
private ISwitchManager switchManager;
private ITopologyManager topologyManager;
Bandwidth.BandwidthPropName);
long srcLinkSpeed = 0, dstLinkSpeed = 0;
- if ((bwSrc == null) || ((srcLinkSpeed = bwSrc.getValue()) == 0)) {
- log.debug("srcNC: {} - Setting srcLinkSpeed to Default!",srcNC);
- srcLinkSpeed = DEFAULT_LINK_SPEED;
+ if ((bwSrc == null)
+ || ((srcLinkSpeed = bwSrc.getValue()) == 0)) {
+ log.debug(
+ "srcNC: {} - Setting srcLinkSpeed to Default!",
+ srcNC);
+ srcLinkSpeed = DEFAULT_LINK_SPEED;
}
-
- if ((bwDst == null) || ((dstLinkSpeed = bwDst.getValue()) == 0)) {
- log.debug("dstNC: {} - Setting dstLinkSpeed to Default!",dstNC);
+
+ if ((bwDst == null)
+ || ((dstLinkSpeed = bwDst.getValue()) == 0)) {
+ log.debug(
+ "dstNC: {} - Setting dstLinkSpeed to Default!",
+ dstNC);
dstLinkSpeed = DEFAULT_LINK_SPEED;
}
long avlDstThruPut = dstLinkSpeed
- readService.getTransmitRate(dstNC);
- //Use lower of the 2 available thruput as the available thruput
+ // Use lower of the 2 available thruput as the available
+ // thruput
long avlThruPut = avlSrcThruPut < avlDstThruPut ? avlSrcThruPut
: avlDstThruPut;
if (avlThruPut <= 0) {
- log.debug("Edge {}: Available Throughput {} <= 0!",
- e, avlThruPut);
+ log.debug("Edge {}: Available Throughput {} <= 0!", e,
+ avlThruPut);
return (double) -1;
}
return (double) (Bandwidth.BW1Pbps / avlThruPut);
};
}
Short baseBW = Short.valueOf((short) 0);
- //Initialize mtp also using the default topo
+ // Initialize mtp also using the default topo
Graph<Node, Edge> g = this.topologyBWAware.get(baseBW);
if (g == null) {
log.error("Default Topology Graph is null");
try {
path = mtp.getMaxThroughputPath(src, dst);
} catch (IllegalArgumentException ie) {
- log.debug("A vertex is yet not known between {} {}", src.toString(),
- dst.toString());
+ log.debug("A vertex is yet not known between {} {}",
+ src.toString(), dst.toString());
return null;
}
Path res;
try {
res = new Path(path);
} catch (ConstructionException e) {
- log.debug("A vertex is yet not known between {} {}", src.toString(),
- dst.toString());
+ log.debug("A vertex is yet not known between {} {}",
+ src.toString(), dst.toString());
return null;
}
return res;
try {
path = spt.getPath(src, dst);
} catch (IllegalArgumentException ie) {
- log.debug("A vertex is yet not known between {} {}", src.toString(),
- dst.toString());
+ log.debug("A vertex is yet not known between {} {}",
+ src.toString(), dst.toString());
return null;
}
Path res;
try {
res = new Path(path);
} catch (ConstructionException e) {
- log.debug("A vertex is yet not known between {} {}", src.toString(),
- dst.toString());
+ log.debug("A vertex is yet not known between {} {}",
+ src.toString(), dst.toString());
return null;
}
return res;
@Override
public synchronized void clearMaxThroughput() {
if (mtp != null) {
- mtp.reset(); //reset maxthruput path
+ mtp.reset(); // reset maxthruput path
}
}
- @SuppressWarnings( { "rawtypes", "unchecked" })
+ @SuppressWarnings({ "rawtypes", "unchecked" })
private synchronized boolean updateTopo(Edge edge, Short bw, boolean added) {
Graph<Node, Edge> topo = this.topologyBWAware.get(bw);
DijkstraShortestPath<Node, Edge> spt = this.sptBWAware.get(bw);
edgePresentInGraph = topo.containsEdge(edge);
if (edgePresentInGraph == false) {
try {
- topo.addEdge(new Edge(src, dst), src
- .getNode(), dst
- .getNode(), EdgeType.DIRECTED);
+ topo.addEdge(new Edge(src, dst), src.getNode(),
+ dst.getNode(), EdgeType.DIRECTED);
} catch (ConstructionException e) {
- log.error("",e);
+ log.error("", e);
return edgePresentInGraph;
}
}
} else {
- //Remove the edge
+ // Remove the edge
try {
topo.removeEdge(new Edge(src, dst));
} catch (ConstructionException e) {
- log.error("",e);
+ log.error("", e);
return edgePresentInGraph;
}
return edgePresentInGraph;
}
- @Override
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
+ private boolean edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
String srcType = null;
String dstType = null;
if (e == null || type == null) {
log.error("Edge or Update type are null!");
- return;
+ return false;
} else {
srcType = e.getTailNodeConnector().getType();
dstType = e.getHeadNodeConnector().getType();
if (srcType.equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
log.debug("Skip updates for {}", e);
- return;
+ return false;
}
if (dstType.equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
log.debug("Skip updates for {}", e);
- return;
+ return false;
}
}
// Update BW topo
updateTopo(e, (short) bw.getValue(), add);
}
- if (this.routingAware != null) {
- for (IListenRoutingUpdates ra : this.routingAware) {
- try {
- ra.recalculateDone();
- } catch (Exception ex) {
- log.error("Exception on routingAware listener call", e);
- }
+ }
+ return newEdge;
+ }
+
+ @Override
+ public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
+ boolean callListeners = false;
+ 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();
+ if ((edgeUpdate(e, type, p)) && (!callListeners)) {
+ callListeners = true;
+ }
+ }
+ if ((callListeners) && (this.routingAware != null)) {
+ for (IListenRoutingUpdates ra : this.routingAware) {
+ try {
+ ra.recalculateDone();
+ } catch (Exception ex) {
+ log.error("Exception on routingAware listener call", ex);
}
}
}
/**
* Function called by the dependency manager when all the required
* dependencies are satisfied
- *
+ *
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void init() {
- log.debug("Routing init() is called");
- this.topologyBWAware = (ConcurrentMap<Short, Graph<Node, Edge>>) new ConcurrentHashMap();
- this.sptBWAware = (ConcurrentMap<Short, DijkstraShortestPath<Node, Edge>>) new ConcurrentHashMap();
- // Now create the default topology, which doesn't consider the
- // BW, also create the corresponding Dijkstra calculation
- Graph<Node, Edge> g = new SparseMultigraph();
- Short sZero = Short.valueOf((short) 0);
- this.topologyBWAware.put(sZero, g);
- this.sptBWAware.put(sZero, new DijkstraShortestPath(g));
- // Topologies for other BW will be added on a needed base
+ log.debug("Routing init() is called");
+ this.topologyBWAware = (ConcurrentMap<Short, Graph<Node, Edge>>) new ConcurrentHashMap();
+ this.sptBWAware = (ConcurrentMap<Short, DijkstraShortestPath<Node, Edge>>) new ConcurrentHashMap();
+ // Now create the default topology, which doesn't consider the
+ // BW, also create the corresponding Dijkstra calculation
+ Graph<Node, Edge> g = new SparseMultigraph();
+ Short sZero = Short.valueOf((short) 0);
+ this.topologyBWAware.put(sZero, g);
+ this.sptBWAware.put(sZero, new DijkstraShortestPath(g));
+ // Topologies for other BW will be added on a needed base
}
+
/**
* Function called by the dependency manager when at least one dependency
* become unsatisfied or when the component is shutting down because for
* example bundle is being stopped.
- *
+ *
*/
void destroy() {
- log.debug("Routing destroy() is called");
+ log.debug("Routing destroy() is called");
}
/**
- * Function called by dependency manager after "init ()" is called
- * and after the services provided by the class are registered in
- * the service registry
- *
+ * Function called by dependency manager after "init ()" is called and after
+ * the services provided by the class are registered in the service registry
+ *
*/
- void start() {
- log.debug("Routing start() is called");
- // build the routing database from the topology if it exists.
- Map<Edge, Set<Property>> edges = topologyManager.getEdges();
- if (edges.isEmpty()) {
- return;
- }
- log.debug("Creating routing database from the topology");
- for (Iterator<Map.Entry<Edge,Set<Property>>> i = edges.entrySet().iterator(); i.hasNext();) {
- Map.Entry<Edge, Set<Property>> entry = i.next();
- Edge e = entry.getKey();
- Set<Property> props = entry.getValue();
- edgeUpdate(e, UpdateType.ADDED, props);
- }
- }
+ void start() {
+ log.debug("Routing start() is called");
+ // build the routing database from the topology if it exists.
+ Map<Edge, Set<Property>> edges = topologyManager.getEdges();
+ if (edges.isEmpty()) {
+ return;
+ }
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
+ log.debug("Creating routing database from the topology");
+ for (Iterator<Map.Entry<Edge, Set<Property>>> i = edges.entrySet()
+ .iterator(); i.hasNext();) {
+ Map.Entry<Edge, Set<Property>> entry = i.next();
+ Edge e = entry.getKey();
+ Set<Property> props = entry.getValue();
+ TopoEdgeUpdate topoedgeupdate = new TopoEdgeUpdate(e, props,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(topoedgeupdate);
+ }
+ edgeUpdate(topoedgeupdateList);
+ }
/**
* Function called by the dependency manager before the services exported by
* the component are unregistered, this will be followed by a "destroy ()"
* calls
- *
+ *
*/
- public void stop() {
- log.debug("Routing stop() is called");
- }
+ public void stop() {
+ log.debug("Routing stop() is called");
+ }
@Override
public void edgeOverUtilized(Edge edge) {
this.readService = null;
}
}
-
+
public void setTopologyManager(ITopologyManager tm) {
- this.topologyManager = tm;
+ this.topologyManager = tm;
}
-
+
public void unsetTopologyManager(ITopologyManager tm) {
- if (this.topologyManager == tm) {
- this.topologyManager = null;
- }
+ if (this.topologyManager == tm) {
+ this.topologyManager = null;
+ }
}
}
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.routing.dijkstra_implementation;
import org.opendaylight.controller.sal.core.Bandwidth;
import org.opendaylight.controller.sal.core.Path;
import org.opendaylight.controller.sal.core.Property;
import org.opendaylight.controller.sal.core.UpdateType;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
import org.opendaylight.controller.sal.utils.NodeCreator;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
public class DijkstraTest {
protected static final Logger logger = LoggerFactory
- .getLogger(DijkstraTest.class);
+ .getLogger(DijkstraTest.class);
+
@Test
public void testSinglePathRouteNoBw() {
DijkstraImplementation imp = new DijkstraImplementation();
Node node1 = NodeCreator.createOFNode((long) 1);
Node node2 = NodeCreator.createOFNode((long) 2);
Node node3 = NodeCreator.createOFNode((long) 3);
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
(short) 1, node1);
NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
try {
edge1 = new Edge(nc11, nc21);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props = new HashSet<Property>();
props.add(new Bandwidth(0));
- imp.edgeUpdate(edge1, UpdateType.ADDED, props);
+ TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
+ topoedgeupdateList.add(teu1);
+
NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
(short) 2, node2);
NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
try {
edge2 = new Edge(nc22, nc31);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props2 = new HashSet<Property>();
- props.add(new Bandwidth(0));
- imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
+ props2.add(new Bandwidth(0));
+ TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu2);
+ imp.edgeUpdate(topoedgeupdateList);
Path res = imp.getRoute(node1, node3);
List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
try {
expectedRes = new Path(expectedPath);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
if (!res.equals(expectedRes)) {
System.out.println("Actual Res is " + res);
@Test
public void testShortestPathRouteNoBw() {
DijkstraImplementation imp = new DijkstraImplementation();
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
imp.init();
Node node1 = NodeCreator.createOFNode((long) 1);
Node node2 = NodeCreator.createOFNode((long) 2);
try {
edge1 = new Edge(nc11, nc21);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props = new HashSet<Property>();
props.add(new Bandwidth(0));
- imp.edgeUpdate(edge1, UpdateType.ADDED, props);
+ TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
+ topoedgeupdateList.add(teu1);
NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
(short) 2, node2);
try {
edge2 = new Edge(nc22, nc31);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props2 = new HashSet<Property>();
- props.add(new Bandwidth(0));
- imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
+ props2.add(new Bandwidth(0));
+ TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu2);
NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
(short) 2, node1);
try {
edge3 = new Edge(nc12, nc32);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props3 = new HashSet<Property>();
- props.add(new Bandwidth(0));
- imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
+ props3.add(new Bandwidth(0));
+ TopoEdgeUpdate teu3 = new TopoEdgeUpdate(edge3, props3,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu3);
+ imp.edgeUpdate(topoedgeupdateList);
Path res = imp.getRoute(node1, node3);
try {
expectedRes = new Path(expectedPath);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
if (!res.equals(expectedRes)) {
System.out.println("Actual Res is " + res);
public void testShortestPathRouteNoBwAfterLinkDelete() {
DijkstraImplementation imp = new DijkstraImplementation();
imp.init();
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
Node node1 = NodeCreator.createOFNode((long) 1);
Node node2 = NodeCreator.createOFNode((long) 2);
Node node3 = NodeCreator.createOFNode((long) 3);
try {
edge1 = new Edge(nc11, nc21);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props = new HashSet<Property>();
props.add(new Bandwidth(0));
- imp.edgeUpdate(edge1, UpdateType.ADDED, props);
+ TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
+ topoedgeupdateList.add(teu1);
NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
(short) 2, node2);
try {
edge2 = new Edge(nc22, nc31);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props2 = new HashSet<Property>();
- props.add(new Bandwidth(0));
- imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
+ props2.add(new Bandwidth(0));
+ TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu2);
NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
(short) 2, node1);
try {
edge3 = new Edge(nc12, nc32);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
Set<Property> props3 = new HashSet<Property>();
- props.add(new Bandwidth(0));
- imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
+ props3.add(new Bandwidth(0));
+ TopoEdgeUpdate teu3 = new TopoEdgeUpdate(edge3, props3,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu3);
+ TopoEdgeUpdate teu4 = new TopoEdgeUpdate(edge3, props3,
+ UpdateType.REMOVED);
+ topoedgeupdateList.add(teu4);
- imp.edgeUpdate(edge3, UpdateType.REMOVED, props3);
+ imp.edgeUpdate(topoedgeupdateList);
Path res = imp.getRoute(node1, node3);
List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
try {
expectedRes = new Path(expectedPath);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
if (!res.equals(expectedRes)) {
System.out.println("Actual Res is " + res);
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.core.Path;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
import org.opendaylight.controller.sal.utils.NodeCreator;
+
import java.util.LinkedList;
import java.util.List;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class MaxThruputTest {
protected static final Logger logger = LoggerFactory
- .getLogger(MaxThruputTest.class);
+ .getLogger(MaxThruputTest.class);
Map<Edge, Number> LinkCostMap = new HashMap<Edge, Number>();
@Test
try {
edge1 = new Edge(nc11, nc21);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge1, 10);
Edge edge2 = null;
try {
edge2 = new Edge(nc21, nc11);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge2, 10);
try {
edge3 = new Edge(nc22, nc31);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge3, 30);
Edge edge4 = null;
try {
edge4 = new Edge(nc31, nc22);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge4, 30);
try {
edge5 = new Edge(nc32, nc41);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge5, 10);
Edge edge6 = null;
try {
edge6 = new Edge(nc41, nc32);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge6, 10);
try {
edge7 = new Edge(nc12, nc51);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge7, 20);
Edge edge8 = null;
try {
edge8 = new Edge(nc51, nc12);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge8, 20);
try {
edge9 = new Edge(nc52, nc61);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge9, 20);
Edge edge10 = null;
try {
edge10 = new Edge(nc61, nc52);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge10, 20);
try {
edge11 = new Edge(nc62, nc42);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge11, 20);
Edge edge12 = null;
try {
edge12 = new Edge(nc42, nc62);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
LinkCostMap.put(edge12, 20);
- imp.edgeUpdate(edge1, UpdateType.ADDED, null);
- imp.edgeUpdate(edge2, UpdateType.ADDED, null);
- imp.edgeUpdate(edge3, UpdateType.ADDED, null);
- imp.edgeUpdate(edge4, UpdateType.ADDED, null);
- imp.edgeUpdate(edge5, UpdateType.ADDED, null);
- imp.edgeUpdate(edge6, UpdateType.ADDED, null);
- imp.edgeUpdate(edge7, UpdateType.ADDED, null);
- imp.edgeUpdate(edge8, UpdateType.ADDED, null);
- imp.edgeUpdate(edge9, UpdateType.ADDED, null);
- imp.edgeUpdate(edge10, UpdateType.ADDED, null);
- imp.edgeUpdate(edge11, UpdateType.ADDED, null);
- imp.edgeUpdate(edge12, UpdateType.ADDED, null);
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
+ TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu1);
+ TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu2);
+ TopoEdgeUpdate teu3 = new TopoEdgeUpdate(edge3, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu3);
+ TopoEdgeUpdate teu4 = new TopoEdgeUpdate(edge4, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu4);
+ TopoEdgeUpdate teu5 = new TopoEdgeUpdate(edge5, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu5);
+ TopoEdgeUpdate teu6 = new TopoEdgeUpdate(edge6, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu6);
+ TopoEdgeUpdate teu7 = new TopoEdgeUpdate(edge7, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu7);
+ TopoEdgeUpdate teu8 = new TopoEdgeUpdate(edge8, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu8);
+ TopoEdgeUpdate teu9 = new TopoEdgeUpdate(edge9, null, UpdateType.ADDED);
+ topoedgeupdateList.add(teu9);
+ TopoEdgeUpdate teu10 = new TopoEdgeUpdate(edge10, null,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu10);
+ TopoEdgeUpdate teu11 = new TopoEdgeUpdate(edge11, null,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu11);
+ TopoEdgeUpdate teu12 = new TopoEdgeUpdate(edge12, null,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu12);
+
+ imp.edgeUpdate(topoedgeupdateList);
imp.initMaxThroughput(LinkCostMap);
try {
expectedRes = new Path(expectedPath);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
if (!res.equals(expectedRes)) {
System.out.println("Actual Res is " + res);
try {
expectedRes = new Path(expectedPath);
} catch (ConstructionException e) {
- logger.error("",e);
+ logger.error("", e);
}
if (!res.equals(expectedRes)) {
System.out.println("Actual Res is " + res);
\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.4.0-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
<packaging>bundle</packaging>\r
\r
<build>\r
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
/**
* The class represents Admin Config status
- *
- *
+ *
+ *
*/
@XmlRootElement
@SuppressWarnings("serial")
@Override
public String toString() {
- return "Config[" + ReflectionToStringBuilder.toString(this) + "]";
+ return "Config["+ReflectionToStringBuilder.toString(this)+"]";
}
}
ConcurrentHashMap<String, ImmutablePair<Class<? extends Object>, String>> compatibleType =
new ConcurrentHashMap<String, ImmutablePair<Class<? extends Object>, String>>();
/**
- * Represent a special port pointing toward the controller,
- * this is to send data packets toward the controller from
- * data plane.
+ * Represents the OFPP_CONTROLLER reserved port to forward a
+ * packet to the controller, this is to send data packets
+ * to the controller from the data plane triggering
+ * a packet_in event.
*/
public static String CONTROLLER = "CTRL";
/**
- * Special port describing ALL the ports in the system,
- * should be used for flooding like mechanism but better
- * to be careful with it
+ * Represents the OFPP_ALL reserved OF port
+ * to forward to ALL the ports in the system ,
+ * should be used for flooding like mechanism to
+ * be used cautiously to avoid excessive flooding.
*/
public static String ALL = "ALL";
/**
- * Describe the local networking stack of the node
- * on which the packet is destined. Yet another special port
+ * Represents the OFPP_LOCAL reserved OF port
+ * to access the local networking stack of the node
+ * of which the packet is destined. Typically used for
+ * inband OF communications channel.
*/
public static String SWSTACK = "SW";
/**
- * Describe a special destination that invoke the
- * traditional HW forwarding on platforms that has this
- * provision.
+ * Describes OFPP_Normal reserved port destination that invokes
+ * the traditional native L2/L3 HW normal forwarding functionality
+ * if supported on the forwarding element.
*/
public static String HWPATH = "HW";
public static String OPENFLOW = "OF";
*
* @param str String to be parsed in a NodeConnector
*
- * @return the NodeConnector if parse is succesfull, null otherwise
+ * @return the NodeConnector if parse is successful, null otherwise
*/
public static NodeConnector fromString(String str) {
if (str == null) {
/**
* return a NodeConnector from a pair (type, ID) in string format
- * not containing explicitely the Node portion which has to be
+ * not containing explicitly the Node portion which has to be
* supplied as parameter
*
* @param typeStr type String to be parsed in a NodeConnector
* @param IDStr ID String portion to be parsed in a NodeConnector
* @param n Node to which the NodeConnector is attached
*
- * @return the NodeConnector if parse is succesfull, null otherwise
+ * @return the NodeConnector if parse is successful, null otherwise
*/
public static NodeConnector fromStringNoNode(String typeStr, String IDStr,
Node n) {
import org.opendaylight.controller.sal.core.UpdateType;
/**
- * The interface class provides the methods to notify the listener when an edge
- * is added/deleted/changed
+ * The interface provides the methods to notify the listener when an edge is
+ * added/deleted/changed.
*/
public interface IDiscoveryService {
/**
import org.opendaylight.controller.sal.core.Property;
/**
- * Interface class that describes methods invoked from application toward SAL to
- * solicit existing inventory data
+ * The Interface describes methods invoked from application toward SAL to
+ * solicit existing inventory data.
*/
public interface IInventoryService {
/**
import org.opendaylight.controller.sal.core.UpdateType;
/**
- * The interface class provides the methods to notify the upper applications
- * in regards to any inventory changes.
+ * The interface provides the methods to notify the upper applications in
+ * regards to any inventory changes.
*/
public interface IListenInventoryUpdates {
/**
import org.opendaylight.controller.sal.core.Property;
/**
- * The interface class that describes methods invoked from SAL toward the protocol
- * plugin to solicit existing inventory data.
+ * The Interface describes methods invoked from SAL toward the protocol plugin
+ * to solicit existing inventory data.
*/
public interface IPluginInInventoryService {
/**
import org.opendaylight.controller.sal.core.UpdateType;
/**
- * The interface class describes Inventory update methods to be implemented by
- * protocol plugin
+ * The Interface describes Inventory update methods to be implemented by
+ * protocol plugin.
*/
public interface IPluginOutInventoryService {
/**
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
package org.opendaylight.controller.sal.topology;
-import java.util.Set;
+import java.util.List;
import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.UpdateType;
/**
* @file IListenTopoUpdates.java
/**
* Topology notifications provided by SAL toward the application
- *
+ *
*/
public interface IListenTopoUpdates {
/**
* Called to update on Edge in the topology graph
- *
- * @param e Edge being updated
- * @param type Type of update
- * @param props Properties of the edge, like BandWidth and/or Latency etc.
+ *
+ * @param topoedgeupdateList
+ * List of topoedgeupdates Each topoedgeupdate includes edge, its
+ * Properties ( BandWidth and/or Latency etc) and update type.
*/
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props);
+ public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList);
/**
- * Called when an Edge utilization is above the safety threshold
- * configured on the controller
- *
- * @param edge The edge which bandwidth usage is above the safety level
+ * Called when an Edge utilization is above the safety threshold configured
+ * on the controller
+ *
+ * @param edge
+ * The edge which bandwidth usage is above the safety level
*/
public void edgeOverUtilized(Edge edge);
/**
* Called when the Edge utilization is back to normal, below the safety
* threshold level configured on the controller
- *
+ *
* @param edge
*/
public void edgeUtilBackToNormal(Edge edge);
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
package org.opendaylight.controller.sal.topology;
+import java.util.List;
import java.util.Set;
import org.opendaylight.controller.sal.core.Edge;
/**
* Methods that are invoked from Protocol Plugin toward SAL
- *
+ *
*/
public interface IPluginOutTopologyService {
+
/**
* Called to update on Edge in the topology graph
- *
- * @param e Edge being updated
- * @param type Type of update
- * @param props Properties of the edge, like BandWidth and/or Latency etc.
+ *
+ * @param topoedgeupdateList
+ * List of topoedgeupdates Each topoedgeupdate includes edge, its
+ * Properties ( BandWidth and/or Latency etc) and update type.
*/
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props);
+ public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList);
/**
- * Called when an Edge utilization is above the safety threshold
- * configured on the controller
+ * Called when an Edge utilization is above the safety threshold configured
+ * on the controller
*
* @param edge
*/
/**
* Called when the Edge utilization is back to normal, below the safety
* threshold level configured on the controller
- *
+ *
* @param edge
*/
public void edgeUtilBackToNormal(Edge edge);
--- /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.sal.topology;
+
+import java.util.Set;
+
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
+import org.opendaylight.controller.sal.core.Edge;
+import org.opendaylight.controller.sal.core.Property;
+import org.opendaylight.controller.sal.core.UpdateType;
+
+/**
+ * The class represents an Edge, the Edge's Property Set and its UpdateType.
+ */
+
+public class TopoEdgeUpdate {
+ private Edge edge;
+ private Set<Property> props;
+ private UpdateType type;
+
+ public TopoEdgeUpdate(Edge e, Set<Property> p, UpdateType t) {
+ edge = e;
+ props = p;
+ type = t;
+ }
+
+ public Edge getEdge() {
+ return edge;
+ }
+
+ public Set<Property> getProperty() {
+ return props;
+ }
+
+ public UpdateType getUpdateType() {
+ return type;
+ }
+
+ @Override
+ public int hashCode() {
+ return HashCodeBuilder.reflectionHashCode(this);
+ }
+
+ @Override
+ public String toString() {
+ return "TopoEdgeUpdate[" + ReflectionToStringBuilder.toString(this)
+ + "]";
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return EqualsBuilder.reflectionEquals(this, obj);
+ }
+}
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.4.0-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
</dependency>\r
</dependencies>\r
</project>\r
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
package org.opendaylight.controller.sal.implementation.internal;
+import java.util.ArrayList;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
import java.util.Collections;
import org.opendaylight.controller.sal.topology.IPluginInTopologyService;
import org.opendaylight.controller.sal.topology.IPluginOutTopologyService;
import org.opendaylight.controller.sal.topology.ITopologyService;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Function called by the dependency manager when all the required
* dependencies are satisfied
- *
+ *
*/
void init() {
}
/**
- * Function called by the dependency manager when at least one
- * dependency become unsatisfied or when the component is shutting
- * down because for example bundle is being stopped.
- *
+ * Function called by the dependency manager when at least one dependency
+ * become unsatisfied or when the component is shutting down because for
+ * example bundle is being stopped.
+ *
*/
void destroy() {
// Make sure to clear all the data structure we use to track
}
@Override
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
+ public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
synchronized (this.updateService) {
for (IListenTopoUpdates s : this.updateService) {
- s.edgeUpdate(e, type, props);
+ s.edgeUpdate(topoedgeupdateList);
}
}
}
}
return null;
}
-
- // private String resolveGeneratedTypePackageName(final SchemaPath
- // schemaPath) {
- // final StringBuilder builder = new StringBuilder();
- // builder.append(basePackageName);
- // if ((schemaPath != null) && (schemaPath.getPath() != null)) {
- // final List<QName> pathToNode = schemaPath.getPath();
- // final int traversalSteps = (pathToNode.size() - 1);
- // for (int i = 0; i < traversalSteps; ++i) {
- // builder.append(".");
- // String nodeLocalName = pathToNode.get(i).getLocalName();
- //
- // // TODO: refactor with use of BindingGeneratorUtil class
- // nodeLocalName = nodeLocalName.replace(":", ".");
- // nodeLocalName = nodeLocalName.replace("-", ".");
- // builder.append(nodeLocalName);
- // }
- // return validatePackage(builder.toString());
- // }
- // return null;
- // }
-
+
+ private List<GeneratedType> augmentationToGenTypes(final Module module) {
+ final List<GeneratedType> augmentGenTypes = new ArrayList<GeneratedType>();
+
+ //TODO: add implementation
+
+ return augmentGenTypes;
+ }
+
private GeneratedType containerToGenType(ContainerSchemaNode container) {
if (container == null) {
return null;
-/*\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
-package org.opendaylight.controller.sal.binding.yang.types;\r
-\r
-import java.math.BigDecimal;\r
-import java.math.BigInteger;\r
-import java.util.HashMap;\r
-import java.util.Map;\r
-\r
-import org.opendaylight.controller.binding.generator.util.Types;\r
-import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;\r
-import org.opendaylight.controller.sal.binding.model.api.Type;\r
-import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
-\r
-public class BaseYangTypes {\r
-\r
- private static Map<String, Type> typeMap = new HashMap<String, Type>();\r
-\r
- public static final Type BOOLEAN_TYPE = Types.typeForClass(Boolean.class);\r
- public static final Type INT8_TYPE = Types.typeForClass(Byte.class);\r
- public static final Type INT16_TYPE = Types.typeForClass(Short.class);\r
- public static final Type INT32_TYPE = Types.typeForClass(Integer.class);\r
- public static final Type INT64_TYPE = Types.typeForClass(Long.class);\r
- public static final Type STRING_TYPE = Types.typeForClass(String.class);\r
- public static final Type DECIMAL64_TYPE = Types.typeForClass(Double.class);\r
- public static final Type UINT8_TYPE = Types.typeForClass(Short.class);\r
- public static final Type UINT16_TYPE = Types.typeForClass(Integer.class);\r
- public static final Type UINT32_TYPE = Types.typeForClass(Long.class);\r
- public static final Type UINT64_TYPE = Types.typeForClass(BigInteger.class);\r
-\r
- static {\r
- typeMap.put("boolean", BOOLEAN_TYPE);\r
- typeMap.put("int8", INT8_TYPE);\r
- typeMap.put("int16", INT16_TYPE);\r
- typeMap.put("int32", INT32_TYPE);\r
- typeMap.put("int64", INT64_TYPE);\r
- typeMap.put("string", STRING_TYPE);\r
- typeMap.put("decimal64", DECIMAL64_TYPE);\r
- typeMap.put("uint8", UINT8_TYPE);\r
- typeMap.put("uint16", UINT16_TYPE);\r
- typeMap.put("uint32", UINT32_TYPE);\r
- typeMap.put("uint64", UINT64_TYPE);\r
- }\r
-\r
- public static final TypeProvider BASE_YANG_TYPES_PROVIDER = new TypeProvider() {\r
-\r
- @Override\r
- public Type javaTypeForYangType(String type) {\r
- return typeMap.get(type);\r
- }\r
-\r
- @Override\r
- public Type javaTypeForSchemaDefinitionType(TypeDefinition<?> type) {\r
- if (type != null) {\r
- return typeMap.get(type.getQName().getLocalName());\r
- }\r
-\r
- return null;\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.sal.binding.yang.types;
+
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.opendaylight.controller.binding.generator.util.Types;
+import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
+import org.opendaylight.controller.sal.binding.model.api.Type;
+import org.opendaylight.controller.yang.model.api.TypeDefinition;
+
+public class BaseYangTypes {
+
+ private static Map<String, Type> typeMap = new HashMap<String, Type>();
+
+ public static final Type BOOLEAN_TYPE = Types.typeForClass(Boolean.class);
+ public static final Type INT8_TYPE = Types.typeForClass(Byte.class);
+ public static final Type INT16_TYPE = Types.typeForClass(Short.class);
+ public static final Type INT32_TYPE = Types.typeForClass(Integer.class);
+ public static final Type INT64_TYPE = Types.typeForClass(Long.class);
+ public static final Type STRING_TYPE = Types.typeForClass(String.class);
+ public static final Type DECIMAL64_TYPE = Types.typeForClass(Double.class);
+ public static final Type UINT8_TYPE = Types.typeForClass(Short.class);
+ public static final Type UINT16_TYPE = Types.typeForClass(Integer.class);
+ public static final Type UINT32_TYPE = Types.typeForClass(Long.class);
+ public static final Type UINT64_TYPE = Types.typeForClass(BigInteger.class);
+
+ static {
+ typeMap.put("boolean", BOOLEAN_TYPE);
+ typeMap.put("int8", INT8_TYPE);
+ typeMap.put("int16", INT16_TYPE);
+ typeMap.put("int32", INT32_TYPE);
+ typeMap.put("int64", INT64_TYPE);
+ typeMap.put("string", STRING_TYPE);
+ typeMap.put("decimal64", DECIMAL64_TYPE);
+ typeMap.put("uint8", UINT8_TYPE);
+ typeMap.put("uint16", UINT16_TYPE);
+ typeMap.put("uint32", UINT32_TYPE);
+ typeMap.put("uint64", UINT64_TYPE);
+ }
+
+ public static final TypeProvider BASE_YANG_TYPES_PROVIDER = new TypeProvider() {
+
+ @Override
+ public Type javaTypeForYangType(String type) {
+ return typeMap.get(type);
+ }
+
+ @Override
+ public Type javaTypeForSchemaDefinitionType(TypeDefinition<?> type) {
+ if (type != null) {
+ return typeMap.get(type.getQName().getLocalName());
+ }
+
+ return null;
+ }
+ };
+
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.binding.generator.util.Types;
import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
import org.opendaylight.controller.sal.binding.model.api.CodeGenerator;
import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
+import org.opendaylight.controller.sal.binding.model.api.Type;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class GeneratorJavaFile {
+ private static final Logger log = LoggerFactory
+ .getLogger(GeneratorJavaFile.class);
private final CodeGenerator interfaceGenerator;
private final ClassCodeGenerator classGenerator;
- private final Set<GeneratedType> types;
+ private final Set<GeneratedType> genTypes;
private final Set<GeneratedTransferObject> genTransferObjects;
public GeneratorJavaFile(final CodeGenerator codeGenerator,
final Set<GeneratedType> types) {
this.interfaceGenerator = codeGenerator;
- this.types = types;
+ this.genTypes = types;
this.genTransferObjects = new HashSet<GeneratedTransferObject>();
classGenerator = new ClassCodeGenerator();
}
final Set<GeneratedTransferObject> genTransferObjects) {
this.interfaceGenerator = new InterfaceGenerator();
this.classGenerator = new ClassCodeGenerator();
- this.types = types;
+ this.genTypes = types;
this.genTransferObjects = genTransferObjects;
}
- public List<File> generateToFile() throws IOException {
- return generateToFile(null);
- }
-
+ @Deprecated
public List<File> generateToFile(String path) throws IOException {
final List<File> result = new ArrayList<File>();
- for (GeneratedType type : types) {
- String parentPath = generateParentPath(path,
- type.getPackageName());
+ for (GeneratedType genType : genTypes) {
+ final String parentPath = generateParentPath(path,
+ genType.getPackageName());
- File file = new File(parentPath, type.getName() + ".java");
- File parent = file.getParentFile();
- if (!parent.exists()) {
- parent.mkdirs();
+ final File directory = new File(parentPath);
+ final File genFile = generateTypeToJavaFile(directory, genType,
+ interfaceGenerator);
+
+ if (genFile != null) {
+ result.add(genFile);
}
+ }
- if (!file.exists()) {
- FileWriter fw = null;
- BufferedWriter bw = null;
+ for (GeneratedTransferObject transferObject : genTransferObjects) {
+ final String parentPath = generateParentPath(path,
+ transferObject.getPackageName());
- file.createNewFile();
- fw = new FileWriter(file);
- bw = new BufferedWriter(fw);
- Writer writer = interfaceGenerator.generate(type);
- bw.write(writer.toString());
+ final File directory = new File(parentPath);
+ final File genFile = generateTypeToJavaFile(directory,
+ transferObject, classGenerator);
- if (bw != null) {
- bw.close();
- }
- result.add(file);
+ if (genFile != null) {
+ result.add(genFile);
}
}
+ return result;
+ }
+ public List<File> generateToFile(final File directory) throws IOException {
+ final List<File> result = new ArrayList<File>();
+ for (GeneratedType type : genTypes) {
+ final File genFile = generateTypeToJavaFile(directory, type,
+ interfaceGenerator);
+
+ if (genFile != null) {
+ result.add(genFile);
+ }
+ }
for (GeneratedTransferObject transferObject : genTransferObjects) {
- String parentPath = generateParentPath(path,
- transferObject.getPackageName());
+ final File genFile = generateTypeToJavaFile(directory,
+ transferObject, classGenerator);
- File file = new File(parentPath, transferObject.getName() + ".java");
- File parent = file.getParentFile();
- if (!parent.exists()) {
- parent.mkdirs();
+ if (genFile != null) {
+ result.add(genFile);
}
+ }
+ return result;
+ }
- if (!file.exists()) {
- FileWriter fw = null;
- BufferedWriter bw = null;
+ private File generateTypeToJavaFile(final File directory, final Type type,
+ final CodeGenerator generator) throws IOException {
+ if ((directory != null) && (type != null) && (generator != null)) {
+ if (!directory.exists()) {
+ directory.mkdirs();
+ }
+
+ final File file = new File(directory, type.getName() + ".java");
+ try (final FileWriter fw = new FileWriter(file)) {
file.createNewFile();
- fw = new FileWriter(file);
- bw = new BufferedWriter(fw);
- Writer writer = classGenerator.generate(transferObject);
- bw.write(writer.toString());
- if (bw != null) {
- bw.close();
+ try (final BufferedWriter bw = new BufferedWriter(fw)) {
+ Writer writer = generator.generate(type);
+ bw.write(writer.toString());
}
- result.add(file);
+ } catch (IOException e) {
+ log.error(e.getMessage());
+ throw new IOException(e.getMessage());
}
- }
- return result;
+ return file;
+ }
+ return null;
}
private String generateParentPath(String path, String pkg) {
}
return fullPath;
}
-
}
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
new InterfaceGenerator(), types);
generator.generateToFile(PATH);
- String[] files = new File(PATH + FS + "org" + FS + "opendaylight" + FS + "controller" + FS + "gen").list();
+ String[] files = new File(PATH + FS + "org" + FS + "opendaylight" + FS
+ + "controller" + FS + "gen").list();
List<String> filesList = Arrays.asList(files);
assertEquals(3, files.length);
assertTrue(filesList.contains("Type2.java"));
assertTrue(filesList.contains("Type3.java"));
}
-
+
@Test
public void compilationTest() throws Exception {
final YangModelParserImpl parser = new YangModelParserImpl();
final File sourcesDir = new File("src/test/resources/yang");
final List<File> sourceFiles = new ArrayList<File>();
final File[] fileArray = sourcesDir.listFiles();
-
+
for (int i = 0; i < fileArray.length; ++i) {
sourceFiles.add(fileArray[i]);
}
-// String[] sourcesDirPaths = new String[sourceFiles.length];
-// for (int i = 0; i < sourceFiles.length; i++) {
-// sourcesDirPaths[i] = sourceFiles[i].getAbsolutePath();
-// }
- final Set<Module> modulesToBuild = parser
- .parseYangModels(sourceFiles);
+ final Set<Module> modulesToBuild = parser.parseYangModels(sourceFiles);
final SchemaContext context = parser
.resolveSchemaContext(modulesToBuild);
final Set<GeneratedType> typesToGenerate = new HashSet<GeneratedType>();
final Set<GeneratedTransferObject> tosToGenerate = new HashSet<GeneratedTransferObject>();
for (Type type : types) {
- if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
+ if (type instanceof GeneratedType
+ && !(type instanceof GeneratedTransferObject)) {
typesToGenerate.add((GeneratedType) type);
}
/**
* Search recursively given directory for *.java files.
- *
+ *
* @param directory
* directory to search
* @return List of java files found
<goal>generate-sources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<codeGenerators>
<generator>
<codeGeneratorClass>
+++ /dev/null
-module types1 {
- yang-version 1;
- namespace "urn:simple.container.demo";
- prefix "t1";
-
- import types2 {
- prefix "data";
- revision-date 2013-02-27;
- }
-
- organization "Cisco";
- contact "WILL-BE-DEFINED-LATER";
-
- revision "2013-02-27" {
- reference " WILL BE DEFINED LATER";
- }
-
- container interfaces {
- list ifEntry {
- key "ifIndex";
-
- leaf ifIndex {
- type uint32;
- units minutes;
- }
-
- leaf ifMtu {
- type int32;
- }
- }
- }
-
- leaf testleaf {
- type data:my-base-int32-type {
- range "min..max";
- }
- }
-
- leaf test-string-leaf {
- type data:my-string-type-ext;
- }
-
- leaf test-int-leaf {
- type data:my-int-type-ext;
- }
-
- leaf test-decimal-leaf {
- type data:my-decimal-type {
- fraction-digits 4;
- }
- }
-
- leaf test-decimal-leaf2 {
- type data:my-decimal-type-ext;
- }
-
-}
+++ /dev/null
-module types2 {
- yang-version 1;
- namespace "urn:simple.types.data.demo";
- prefix "t2";
-
- import types1 {
- prefix "if";
- revision-date 2013-02-27;
- }
-
- organization "Cisco";
- contact "WILL-BE-DEFINED-LATER";
- description "This is types-data test description";
-
- revision "2013-02-27" {
- reference " WILL BE DEFINED LATER";
- }
-
- typedef my-base-int32-type {
- type int32 {
- range "2..20";
- }
- }
-
- typedef my-type1 {
- type my-base-int32-type {
- range "11..max";
- }
- }
-
- typedef my-string-type {
- type string {
- pattern "[a-k]*";
- }
- }
-
- typedef my-string-type2 {
- type my-string-type {
- pattern "[b-u]*";
- }
- }
-
- typedef my-string-type-ext {
- type my-string-type2 {
- pattern "[e-z]*";
- }
- }
-
- typedef my-int-type {
- type int32 {
- range "10..20";
- }
- }
-
- typedef my-int-type2 {
- type my-int-type {
- range "12..18";
- }
- }
-
- typedef my-int-type-ext {
- type my-int-type2 {
- range "14..16";
- }
- }
-
- typedef my-decimal-type {
- type decimal64 {
- fraction-digits 6;
- }
- }
-
- typedef my-decimal-type-ext {
- type decimal64 {
- fraction-digits 5;
- }
- }
-
- augment "/if:interfaces/if:ifEntry" {
- when "if:ifType='ds0'";
- leaf ds0ChannelNumber {
- type string;
- }
- }
-
- leaf if-name {
- type leafref {
- path "/interface/name";
- }
- }
-
- leaf name {
- type string;
- }
-
- leaf nested-type-leaf {
- type my-type1;
- }
-
-}
<goal>generate-resources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<codeGenerators>
<generator>
<codeGeneratorClass>
<goal>generate-resources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<resourceProviders>
<provider>
<resourceProviderClass>
<goal>generate-sources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<codeGenerators>
</codeGenerators>
</configuration>
<goal>generate-resources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<resourceProviders>
</resourceProviders>
</configuration>
<goal>generate-sources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<codeGenerators>
<generator>
<codeGeneratorClass>
<goal>generate-resources</goal>
</goals>
<configuration>
- <yangFilesRootDir>${basedir}/../Correct</yangFilesRootDir>
+ <yangFilesRootDir>${basedir}/../../../../../yang-model-parser-impl/src/test/resources/model</yangFilesRootDir>
<resourceProviders>
<provider>
<resourceProviderClass>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"\r
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">\r
- <modelVersion>4.0.0</modelVersion>\r
- <groupId>org.opendaylight.controller</groupId>\r
- <artifactId>binding-generator</artifactId>\r
- <version>1.0</version>\r
- <packaging>pom</packaging>\r
- <name>binding-generator</name>\r
- \r
- <properties>\r
- <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>\r
- </properties>\r
- \r
- <modules>\r
- <module>../yang</module>\r
- <module>../sal/sal-schema-repository-api</module>\r
- <module>code-generator-demo</module>\r
- <module>yang-model-parser-api</module>\r
- <module>yang-model-parser-impl</module>\r
- <module>binding-model-api</module>\r
- <module>binding-generator-api</module>\r
- <module>binding-generator-spi</module>\r
- <module>binding-generator-util</module>\r
- <module>binding-generator-impl</module>\r
- <module>binding-java-api-generator</module>\r
- <module>maven-yang</module>\r
- <module>maven-yang-plugin</module>\r
- <module>maven-yang-plugin-it</module>\r
- <module>maven-sal-api-gen-plugin</module>\r
- </modules>\r
- <dependencies>\r
-\r
- <dependency>\r
- <groupId>junit</groupId>\r
- <artifactId>junit</artifactId>\r
- <version>4.10</version>\r
- <scope>test</scope>\r
- <optional>true</optional>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.slf4j</groupId>\r
- <artifactId>slf4j-api</artifactId>\r
- <version>1.7.2</version>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.slf4j</groupId>\r
- <artifactId>slf4j-simple</artifactId>\r
- <version>1.7.2</version>\r
- </dependency>\r
- </dependencies>\r
- <build>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-compiler-plugin</artifactId>\r
- <version>2.0</version>\r
- <inherited>true</inherited>\r
- <configuration>\r
- <source>1.6</source>\r
- <target>1.6</target>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-javadoc-plugin</artifactId>\r
- <version>2.8.1</version>\r
- <configuration>\r
- <stylesheet>maven</stylesheet>\r
- </configuration>\r
- <executions>\r
- <execution>\r
- <goals>\r
- <goal>aggregate</goal>\r
- </goals>\r
- <phase>site</phase>\r
- </execution>\r
- </executions>\r
- </plugin>\r
- </plugins>\r
- </build>\r
- <reporting>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>findbugs-maven-plugin</artifactId>\r
- <version>2.4.0</version>\r
- <configuration>\r
- <effort>Max</effort>\r
- <threshold>Low</threshold>\r
- <goal>site</goal>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>jdepend-maven-plugin</artifactId>\r
- <version>2.0-beta-2</version>\r
- </plugin>\r
- </plugins>\r
- </reporting>\r
-</project>\r
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>binding-generator</artifactId>
+ <version>1.0</version>
+ <packaging>pom</packaging>
+ <name>binding-generator</name>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ </properties>
+
+ <modules>
+ <module>../yang</module>
+ <module>../sal/sal-schema-repository-api</module>
+ <module>code-generator-demo</module>
+ <module>yang-model-parser-api</module>
+ <module>yang-model-parser-impl</module>
+ <module>binding-model-api</module>
+ <module>binding-generator-api</module>
+ <module>binding-generator-spi</module>
+ <module>binding-generator-util</module>
+ <module>binding-generator-impl</module>
+ <module>binding-java-api-generator</module>
+ <module>maven-yang</module>
+ <module>maven-yang-plugin</module>
+ <module>maven-yang-plugin-it</module>
+ <module>maven-sal-api-gen-plugin</module>
+ </modules>
+ <dependencies>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.10</version>
+ <scope>test</scope>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>1.7.2</version>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-simple</artifactId>
+ <version>1.7.2</version>
+ </dependency>
+ </dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>2.0</version>
+ <inherited>true</inherited>
+ <configuration>
+ <source>1.7</source>
+ <target>1.7</target>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.8.1</version>
+ <configuration>
+ <stylesheet>maven</stylesheet>
+ </configuration>
+ <executions>
+ <execution>
+ <goals>
+ <goal>aggregate</goal>
+ </goals>
+ <phase>site</phase>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <reporting>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>findbugs-maven-plugin</artifactId>
+ <version>2.4.0</version>
+ <configuration>
+ <effort>Max</effort>
+ <threshold>Low</threshold>
+ <goal>site</goal>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>jdepend-maven-plugin</artifactId>
+ <version>2.0-beta-2</version>
+ </plugin>
+ </plugins>
+ </reporting>
+</project>
public class ChoiceBuilder implements DataSchemaNodeBuilder, ChildNodeBuilder,
AugmentationTargetBuilder {
+ private final ChoiceNodeImpl instance;
+ // SchemaNode args
private final QName qname;
private SchemaPath schemaPath;
- private final ConstraintsBuilder constraints;
- private final ChoiceNodeImpl instance;
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
private boolean configuration;
- private String defaultCase;
-
- private final Set<ChoiceCaseBuilder> cases = new HashSet<ChoiceCaseBuilder>();
+ private final ConstraintsBuilder constraints;
+ // DataNodeContainer args
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
+ // AugmentationTarget args
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // ChoiceNode args
+ private final Set<ChoiceCaseBuilder> cases = new HashSet<ChoiceCaseBuilder>();
+ private String defaultCase;
public ChoiceBuilder(QName qname) {
this.qname = qname;
instance.setStatus(status);
instance.setAugmenting(augmenting);
instance.setConfiguration(configuration);
+ instance.setConstraints(constraints.build());
instance.setDefaultCase(defaultCase);
// CASES
}
instance.setUnknownSchemaNodes(unknownNodes);
- instance.setConstraints(constraints.build());
-
return instance;
}
@Override
public void addChildNode(DataSchemaNodeBuilder childNode) {
if (!(childNode instanceof ChoiceCaseBuilder)) {
- ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(childNode.getQName());
+ ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(
+ childNode.getQName());
caseBuilder.addChildNode(childNode);
cases.add(caseBuilder);
} else {
import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
-public class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements DataSchemaNodeBuilder {
-
+public final class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements
+ DataSchemaNodeBuilder {
private final ChoiceCaseNodeImpl instance;
- private final ConstraintsBuilder constraints;
private SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private boolean augmenting;
+ private final ConstraintsBuilder constraints;
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
ChoiceCaseBuilder(QName qname) {
super(qname);
@Override
public void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
@Override
public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
- throw new UnsupportedOperationException("Can not add type definition to choice case.");
+ throw new UnsupportedOperationException(
+ "Can not add type definition to choice case.");
}
@Override
public void setConfiguration(boolean configuration) {
- throw new UnsupportedOperationException("Can not add config definition to choice case.");
+ throw new UnsupportedOperationException(
+ "Can not add config definition to choice case.");
}
@Override
return augmentations;
}
-
- private static class ChoiceCaseNodeImpl implements ChoiceCaseNode {
+ private class ChoiceCaseNodeImpl implements ChoiceCaseNode {
private final QName qname;
private SchemaPath path;
private String description;
}
private void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
}
private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if(unknownNodes != null) {
+ if (unknownNodes != null) {
this.unknownNodes = unknownNodes;
}
}
}
}
-
@Override
public int hashCode() {
final int prime = 31;
*/
package org.opendaylight.controller.yang.model.parser.builder.impl;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.parser.builder.api.SchemaNodeBuilder;
-public class IdentitySchemaNodeBuilder implements SchemaNodeBuilder {
-
+public final class IdentitySchemaNodeBuilder implements SchemaNodeBuilder {
+ private final IdentitySchemaNodeImpl instance;
private final QName qname;
private SchemaPath schemaPath;
- private final IdentitySchemaNodeImpl instance;
private IdentitySchemaNodeBuilder baseIdentity;
private String baseIdentityName;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
IdentitySchemaNodeBuilder(final QName qname) {
this.qname = qname;
@Override
public IdentitySchemaNode build() {
instance.setPath(schemaPath);
-
if (baseIdentity != null) {
- final IdentitySchemaNode base = baseIdentity.build();
- instance.setBaseIdentity(base);
+ instance.setBaseIdentity(baseIdentity.build());
+ }
+
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
}
+ instance.setUnknownSchemaNodes(unknownNodes);
+
return instance;
}
@Override
public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
- throw new IllegalStateException(
- "Can not add schema node to identity statement");
+ addedUnknownNodes.add(unknownNode);
}
public String getBaseIdentityName() {
this.baseIdentity = baseType;
}
- private class IdentitySchemaNodeImpl implements IdentitySchemaNode {
+ private final class IdentitySchemaNodeImpl implements IdentitySchemaNode {
private final QName qname;
private IdentitySchemaNode baseIdentity;
private String description;
private String reference;
private Status status = Status.CURRENT;
private SchemaPath path;
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
private IdentitySchemaNodeImpl(final QName qname) {
this.qname = qname;
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.emptyList();
+ return unknownNodes;
+ }
+
+ private void setUnknownSchemaNodes(
+ List<UnknownSchemaNode> unknownSchemaNodes) {
+ if (unknownSchemaNodes != null) {
+ this.unknownNodes = unknownSchemaNodes;
+ }
}
@Override
*/
@Override
public Module build() {
+ instance.setPrefix(prefix);
+ instance.setRevision(revision);
instance.setImports(imports);
instance.setNamespace(namespace);
public void setRevision(final Date revision) {
this.revision = revision;
- instance.setRevision(revision);
}
public void setPrefix(final String prefix) {
this.prefix = prefix;
- instance.setPrefix(prefix);
}
public void setYangVersion(final String yangVersion) {
public ContainerSchemaNodeBuilder addContainerNode(
final QName containerName, final List<String> parentPath) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
-
final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(
containerName);
-
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
public ListSchemaNodeBuilder addListNode(final QName listName,
final List<String> parentPath) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
-
final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(
listName);
-
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
public LeafSchemaNodeBuilder addLeafNode(final QName leafName,
final List<String> parentPath) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
-
final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(
leafName);
-
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
public LeafListSchemaNodeBuilder addLeafListNode(final QName leafListName,
final List<String> parentPath) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
-
final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(
leafListName);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
public GroupingBuilder addGrouping(final QName qname,
final List<String> parentPath) {
final List<String> pathToGroup = new ArrayList<String>(parentPath);
-
final GroupingBuilder builder = new GroupingBuilderImpl(qname);
final ChildNodeBuilder parentNodeBuilder = (ChildNodeBuilder) moduleNodes
.get(pathToGroup);
public AugmentationSchemaBuilder addAugment(final String name,
final List<String> parentPath) {
final List<String> pathToAugment = new ArrayList<String>(parentPath);
-
final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(
name);
import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;\r
import org.opendaylight.controller.yang.model.parser.util.RefineHolder;\r
\r
-public class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {\r
-\r
+final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {\r
private final UsesNodeImpl instance;\r
private final SchemaPath groupingPath;\r
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
refines.add(refine);\r
}\r
\r
- private SchemaPath parseUsesPath(final String augmentPath) {\r
- final String[] splittedPath = augmentPath.split("/");\r
+ private SchemaPath parseUsesPath(final String groupingPathStr) {\r
+ final String[] splittedPath = groupingPathStr.split("/");\r
final List<QName> path = new ArrayList<QName>();\r
QName name;\r
for (String pathElement : splittedPath) {\r
}\r
path.add(name);\r
}\r
- final boolean absolute = augmentPath.startsWith("/");\r
+ final boolean absolute = groupingPathStr.startsWith("/");\r
return new SchemaPath(path, absolute);\r
}\r
\r
- private static class UsesNodeImpl implements UsesNode {\r
+ private final class UsesNodeImpl implements UsesNode {\r
private final SchemaPath groupingPath;\r
private Set<AugmentationSchema> augmentations = Collections.emptySet();\r
private boolean augmenting;\r
import org.opendaylight.controller.yang.model.parser.builder.impl.TypedefBuilder;
import org.opendaylight.controller.yang.model.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.controller.yang.model.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.controller.yang.model.parser.util.ModuleDependencySort;
+import org.opendaylight.controller.yang.model.parser.util.ModuleDependencySort.ModuleSimple;
import org.opendaylight.controller.yang.model.parser.util.ParserUtils;
import org.opendaylight.controller.yang.model.parser.util.RefineHolder;
import org.opendaylight.controller.yang.model.parser.util.TypeConstraints;
public Set<Module> parseYangModels(final List<File> yangFiles) {
if (yangFiles != null) {
final List<InputStream> inputStreams = new ArrayList<InputStream>();
-
+
for (final File yangFile : yangFiles) {
try {
inputStreams.add(new FileInputStream(yangFile));
}
private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(
- final List<InputStream> yangFileStreams) {
+ final List<InputStream> yangFileStreams) {
final Map<String, TreeMap<Date, ModuleBuilder>> modules = new HashMap<String, TreeMap<Date, ModuleBuilder>>();
final ParseTreeWalker walker = new ParseTreeWalker();
final List<ParseTree> trees = parseStreams(yangFileStreams);
builders[i] = yangModelParser.getModuleBuilder();
}
+ // module dependency graph sorted
+ List<ModuleSimple> sorted = new ModuleDependencySort(builders).sort();
+
for (ModuleBuilder builder : builders) {
final String builderName = builder.getName();
Date builderRevision = builder.getRevision();
tdb.setPatterns(old.getPatterns());
tdb.setFractionDigits(old.getFractionDigits());
tdb.setPath(old.getPath());
-
+
final TypeDefinition<?> oldType = old.getType();
if (oldType == null) {
tdb.setType(old.getTypedef());
final String nodeTypeStr = ctx.getChild(0).getText();
final String[] splittedElement = nodeTypeStr.split(":");
if (splittedElement.length == 1) {
- nodeType = new QName(null, null, null, splittedElement[0]);
+ nodeType = new QName(null, null, yangModelPrefix, splittedElement[0]);
} else {
nodeType = new QName(null, null, splittedElement[0],
splittedElement[1]);
--- /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.yang.model.parser.util;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.yang.model.api.ModuleImport;
+import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.controller.yang.model.parser.impl.YangModelParserListenerImpl;
+import org.opendaylight.controller.yang.model.parser.util.TopologicalSort.Node;
+import org.opendaylight.controller.yang.model.parser.util.TopologicalSort.NodeImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+/**
+ * Creates a module dependency graph from provided {@link ModuleBuilder}s and
+ * provides a {@link #sort()} method. It is topological sort and returns modules
+ * in order in which they should be processed (e.g. if A imports B, sort returns
+ * {B, A}).
+ */
+public final class ModuleDependencySort {
+
+ private static final Date DEFAULT_REVISION = new Date(0);
+ private static final Logger logger = LoggerFactory
+ .getLogger(ModuleDependencySort.class);
+
+ private final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph;
+
+ /**
+ *
+ * @param builders
+ * Source for module dependency graph.
+ * @throws YangValidationException
+ * if 1. there are module:revision duplicates 2. there is
+ * imported not existing module 3. module is imported twice
+ */
+ public ModuleDependencySort(ModuleBuilder... builders) {
+ this.moduleGraph = createModuleGraph(builders);
+ }
+
+ @VisibleForTesting
+ Map<String, Map<Date, ModuleNodeImpl>> getModuleGraph() {
+ return moduleGraph;
+ }
+
+ /**
+ * Topological sort of module dependency graph.
+ *
+ * @return Sorted list of modules. Modules can be further processed in
+ * returned order.
+ */
+ public List<ModuleSimple> sort() {
+ Set<Node> nodes = Sets.newHashSet();
+ for (Map<Date, ModuleNodeImpl> map : moduleGraph.values()) {
+ for (ModuleNodeImpl node : map.values()) {
+ nodes.add(node);
+ }
+ }
+
+ // Cast to ModuleNode from Node
+ return Lists.transform(TopologicalSort.sort(nodes),
+ new Function<Node, ModuleSimple>() {
+
+ @Override
+ public ModuleSimple apply(Node input) {
+ return (ModuleSimple) input;
+ }
+ });
+ }
+
+ private Map<String, Map<Date, ModuleNodeImpl>> createModuleGraph(
+ ModuleBuilder... builders) {
+ Map<String, Map<Date, ModuleNodeImpl>> moduleGraph = Maps.newHashMap();
+
+ processModules(moduleGraph, builders);
+ processDependencies(moduleGraph, builders);
+
+ return moduleGraph;
+ }
+
+ /**
+ * Extract module:revision from module builders
+ */
+ private void processDependencies(
+ Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
+ ModuleBuilder... builders) {
+ Map<String, Date> imported = Maps.newHashMap();
+
+ // Create edges in graph
+ for (ModuleBuilder mb : builders) {
+ String fromName = mb.getName();
+ Date fromRevision = mb.getRevision() == null ? DEFAULT_REVISION
+ : mb.getRevision();
+ for (ModuleImport imprt : mb.getModuleImports()) {
+ String toName = imprt.getModuleName();
+ Date toRevision = imprt.getRevision() == null ? DEFAULT_REVISION
+ : imprt.getRevision();
+
+ ModuleNodeImpl from = moduleGraph.get(fromName).get(
+ fromRevision);
+
+ ModuleNodeImpl to = getModuleByNameAndRevision(moduleGraph,
+ fromName, fromRevision, toName, toRevision);
+
+ /*
+ * Check imports: If module is imported twice with different
+ * revisions then throw exception
+ */
+ if (imported.get(toName) != null
+ && !imported.get(toName).equals(toRevision))
+ ex(String
+ .format("Module:%s imported twice with different revisions:%s, %s",
+ toName,
+ formatRevDate(imported.get(toName)),
+ formatRevDate(toRevision)));
+ imported.put(toName, toRevision);
+
+ from.addEdge(to);
+ }
+ }
+ }
+
+ /**
+ * Get imported module by its name and revision from moduleGraph
+ */
+ private ModuleNodeImpl getModuleByNameAndRevision(
+ Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
+ String fromName, Date fromRevision, String toName, Date toRevision) {
+ ModuleNodeImpl to = null;
+
+ if (moduleGraph.get(toName) == null
+ || !moduleGraph.get(toName).containsKey(toRevision)) {
+ // If revision is not specified in import, but module exists
+ // with different revisions, take first
+ if (moduleGraph.get(toName) != null
+ && !moduleGraph.get(toName).isEmpty()
+ && toRevision.equals(DEFAULT_REVISION)) {
+ to = moduleGraph.get(toName).values().iterator().next();
+ logger.warn(String
+ .format("Import:%s:%s by module:%s:%s does not specify revision, using:%s:%s for module dependency sort",
+ toName, formatRevDate(toRevision), fromName,
+ formatRevDate(fromRevision), to.getName(),
+ formatRevDate(to.getRevision())));
+ } else
+ ex(String.format("Not existing module imported:%s:%s by:%s:%s",
+ toName, formatRevDate(toRevision), fromName,
+ formatRevDate(fromRevision)));
+ } else {
+ to = moduleGraph.get(toName).get(toRevision);
+ }
+ return to;
+ }
+
+ private void ex(String message) {
+ throw new YangValidationException(message);
+ }
+
+ /**
+ * Extract dependencies from module builders to fill dependency graph
+ */
+ private void processModules(
+ Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
+ ModuleBuilder... builders) {
+
+ // Process nodes
+ for (ModuleBuilder mb : builders) {
+ String name = mb.getName();
+
+ Date rev = mb.getRevision();
+ if (rev == null)
+ rev = DEFAULT_REVISION;
+
+ if (moduleGraph.get(name) == null)
+ moduleGraph.put(name, Maps.<Date, ModuleNodeImpl> newHashMap());
+
+ if (moduleGraph.get(name).get(rev) != null)
+ ex(String.format("Module:%s with revision:%s declared twice",
+ name, formatRevDate(rev)));
+
+ moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev));
+ }
+ }
+
+ private static String formatRevDate(Date rev) {
+ return rev == DEFAULT_REVISION ? "default"
+ : YangModelParserListenerImpl.simpleDateFormat.format(rev);
+ }
+
+ /**
+ * Simple representation of module. Contains name and revision.
+ */
+ public interface ModuleSimple {
+ String getName();
+
+ Date getRevision();
+ }
+
+ static class ModuleNodeImpl extends NodeImpl implements ModuleSimple {
+ private final String name;
+ private final Date revision;
+
+ public ModuleNodeImpl(String name, Date revision) {
+ this.name = name;
+ this.revision = revision;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public Date getRevision() {
+ return revision;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((name == null) ? 0 : name.hashCode());
+ result = prime * result
+ + ((revision == null) ? 0 : revision.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ ModuleNodeImpl other = (ModuleNodeImpl) obj;
+ if (name == null) {
+ if (other.name != null)
+ return false;
+ } else if (!name.equals(other.name))
+ return false;
+ if (revision == null) {
+ if (other.revision != null)
+ return false;
+ } else if (!revision.equals(other.revision))
+ return false;
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "Module [name=" + name + ", revision="
+ + formatRevDate(revision) + "]";
+ }
+
+ }
+
+}
--- /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.yang.model.parser.util;
+
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+/**
+ * Utility class that provides topological sort
+ */
+public class TopologicalSort {
+
+ /**
+ * Topological sort of dependent nodes in acyclic graphs.
+ *
+ * @return Sorted {@link List} of {@link Node}s. Order: Nodes with no
+ * dependencies starting.
+ * @throws IllegalStateException
+ * when cycle is present in the graph
+ */
+ public static List<Node> sort(Set<Node> nodes) {
+ List<Node> sortedNodes = Lists.newArrayList();
+
+ Set<Node> dependentNodes = getDependentNodes(nodes);
+
+ while (!dependentNodes.isEmpty()) {
+ Node n = dependentNodes.iterator().next();
+ dependentNodes.remove(n);
+
+ sortedNodes.add(n);
+
+ for (Edge e : n.getInEdges()) {
+ Node m = e.getFrom();
+ m.getOutEdges().remove(e);
+
+ if (m.getOutEdges().isEmpty()) {
+ dependentNodes.add(m);
+ }
+ }
+ }
+
+ detectCycles(nodes);
+
+ return sortedNodes;
+ }
+
+ private static Set<Node> getDependentNodes(Set<Node> nodes) {
+ Set<Node> S = Sets.newHashSet();
+ for (Node n : nodes) {
+ if (n.getOutEdges().size() == 0) {
+ S.add(n);
+ }
+ }
+ return S;
+ }
+
+ private static void detectCycles(Set<Node> nodes) {
+ // Detect cycles
+ boolean cycle = false;
+ Node cycledNode = null;
+
+ for (Node n : nodes) {
+ if (!n.getOutEdges().isEmpty()) {
+ cycle = true;
+ cycledNode = n;
+ break;
+ }
+ }
+ Preconditions.checkState(cycle == false,
+ "Cycle detected in graph around node: " + cycledNode);
+ }
+
+ /**
+ * Interface for nodes in graph that can be sorted topologically
+ */
+ public static interface Node {
+ Set<Edge> getInEdges();
+
+ Set<Edge> getOutEdges();
+ }
+
+ /**
+ * Interface for edges in graph that can be sorted topologically
+ */
+ public static interface Edge {
+ Node getFrom();
+
+ Node getTo();
+ }
+
+ /**
+ * Basic Node implementation.
+ */
+ public static class NodeImpl implements Node {
+ private final Set<Edge> inEdges;
+ private final Set<Edge> outEdges;
+
+ @Override
+ public Set<Edge> getInEdges() {
+ return inEdges;
+ }
+
+ @Override
+ public Set<Edge> getOutEdges() {
+ return outEdges;
+ }
+
+ public void addEdge(Node to) {
+ Edge e = new EdgeImpl(this, to);
+ outEdges.add(e);
+ to.getInEdges().add(e);
+ }
+
+ public NodeImpl() {
+ inEdges = Sets.newHashSet();
+ outEdges = Sets.newHashSet();
+ }
+ }
+
+ /**
+ * Basic Edge implementation
+ */
+ public static class EdgeImpl implements Edge {
+ private final Node from;
+ private final Node to;
+
+ @Override
+ public Node getFrom() {
+ return from;
+ }
+
+ @Override
+ public Node getTo() {
+ return to;
+ }
+
+ public EdgeImpl(Node from, Node to) {
+ this.from = from;
+ this.to = to;
+
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((from == null) ? 0 : from.hashCode());
+ result = prime * result + ((to == null) ? 0 : to.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ EdgeImpl other = (EdgeImpl) obj;
+ if (from == null) {
+ if (other.from != null)
+ return false;
+ } else if (!from.equals(other.from))
+ return false;
+ if (to == null) {
+ if (other.to != null)
+ return false;
+ } else if (!to.equals(other.to))
+ return false;
+ return true;
+ }
+ }
+
+}
import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;
import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
-import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
--- /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.yang.model.parser.util;
+
+import static org.hamcrest.core.AnyOf.*;
+import static org.hamcrest.core.Is.*;
+import static org.junit.Assert.*;
+import static org.junit.matchers.JUnitMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.hamcrest.Matcher;
+import org.junit.Test;
+import org.opendaylight.controller.yang.model.api.ModuleImport;
+import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.controller.yang.model.parser.impl.YangModelParserListenerImpl;
+import org.opendaylight.controller.yang.model.parser.util.ModuleDependencySort.ModuleNodeImpl;
+import org.opendaylight.controller.yang.model.parser.util.ModuleDependencySort.ModuleSimple;
+import org.opendaylight.controller.yang.model.parser.util.TopologicalSort.Edge;
+
+import com.google.common.collect.Sets;
+
+public class ModuleDependencySortTest {
+
+ private ModuleBuilder a = mockModule("a", null);
+ private ModuleBuilder b = mockModule("b", null);
+ private ModuleBuilder c = mockModule("c", null);
+ private ModuleBuilder d = mockModule("d", null);
+
+ @Test
+ public void testValid() throws Exception {
+
+ mockDependency(a, b);
+ mockDependency(b, c);
+ mockDependency(b, d);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { d, b, c, a };
+ ModuleDependencySort sort = new ModuleDependencySort(builders);
+
+ assertDependencyGraph(sort.getModuleGraph());
+
+ List<ModuleSimple> l = sort.sort();
+
+ @SuppressWarnings("unchecked")
+ Matcher<String> cOrD = anyOf(is(c.getName()), is(d.getName()));
+
+ assertThat(l.get(0).getName(), cOrD);
+ assertThat(l.get(1).getName(), cOrD);
+ assertThat(l.get(2).getName(), is(b.getName()));
+ assertThat(l.get(3).getName(), is(a.getName()));
+ }
+
+ @Test(expected = YangValidationException.class)
+ public void testModuleTwice() throws Exception {
+ ModuleBuilder a2 = mockModule("a", null);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a, a2 };
+ try {
+ new ModuleDependencySort(builders);
+ } catch (YangValidationException e) {
+ assertThat(e.getMessage(),
+ containsString("Module:a with revision:default declared twice"));
+ throw e;
+ }
+ }
+
+ @Test(expected = YangValidationException.class)
+ public void testImportNotExistingModule() throws Exception {
+ mockDependency(a, b);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a };
+ try {
+ new ModuleDependencySort(builders);
+ } catch (YangValidationException e) {
+ assertThat(e.getMessage(),
+ containsString("Not existing module imported:b:default by:a:default"));
+ throw e;
+ }
+ }
+
+ @Test
+ public void testImportTwice() throws Exception {
+ mockDependency(a, b);
+ mockDependency(c, b);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a, b, c };
+ new ModuleDependencySort(builders);
+ }
+
+ @Test(expected = YangValidationException.class)
+ public void testImportTwiceDifferentRevision() throws Exception {
+ Date date = new Date();
+ ModuleBuilder b2 = mockModule("b", date);
+
+ mockDependency(a, b);
+ mockDependency(c, b2);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a, c, b, b2 };
+ try {
+ ModuleDependencySort aaa = new ModuleDependencySort(builders);
+ System.out.println(aaa.getModuleGraph());
+ } catch (YangValidationException e) {
+ assertThat(e.getMessage(),
+ containsString("Module:b imported twice with different revisions:default, "
+ + YangModelParserListenerImpl.simpleDateFormat
+ .format(date)));
+ throw e;
+ }
+ }
+
+ @Test
+ public void testModuleTwiceWithDifferentRevs() throws Exception {
+ ModuleBuilder a2 = mockModule("a", new Date());
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a, a2 };
+ new ModuleDependencySort(builders);
+ }
+
+ @Test(expected = YangValidationException.class)
+ public void testModuleTwice2() throws Exception {
+ Date rev = new Date();
+ ModuleBuilder a2 = mockModule("a", rev);
+ ModuleBuilder a3 = mockModule("a", rev);
+
+ ModuleBuilder[] builders = new ModuleBuilder[] { a, a2, a3 };
+ try {
+ new ModuleDependencySort(builders);
+ } catch (YangValidationException e) {
+ assertThat(e.getMessage(), containsString("Module:a with revision:"
+ + YangModelParserListenerImpl.simpleDateFormat.format(rev)
+ + " declared twice"));
+ throw e;
+ }
+ }
+
+ private void assertDependencyGraph(
+ Map<String, Map<Date, ModuleNodeImpl>> moduleGraph) {
+ for (Entry<String, Map<Date, ModuleNodeImpl>> node : moduleGraph
+ .entrySet()) {
+ String name = node.getKey();
+
+ // Expects only one module revision
+
+ Set<Edge> inEdges = node.getValue().values().iterator().next()
+ .getInEdges();
+ Set<Edge> outEdges = node.getValue().values().iterator().next()
+ .getOutEdges();
+
+ if (name.equals("a")) {
+ assertEdgeCount(inEdges, 0, outEdges, 1);
+ } else if (name.equals("b")) {
+ assertEdgeCount(inEdges, 1, outEdges, 2);
+ } else {
+ assertEdgeCount(inEdges, 1, outEdges, 0);
+ }
+ }
+ }
+
+ private void assertEdgeCount(Set<Edge> inEdges, int i, Set<Edge> outEdges,
+ int j) {
+ assertThat(inEdges.size(), is(i));
+ assertThat(outEdges.size(), is(j));
+ }
+
+ private void mockDependency(ModuleBuilder a, ModuleBuilder b) {
+ ModuleImport imprt = mock(ModuleImport.class);
+ doReturn(b.getName()).when(imprt).getModuleName();
+ doReturn(b.getRevision()).when(imprt).getRevision();
+ a.getModuleImports().add(imprt);
+ }
+
+ private ModuleBuilder mockModule(String name, Date rev) {
+ ModuleBuilder a = mock(ModuleBuilder.class);
+ doReturn(name).when(a).getName();
+ Set<ModuleImport> set = Sets.newHashSet();
+ doReturn(set).when(a).getModuleImports();
+ if (rev != null) {
+ doReturn(rev).when(a).getRevision();
+ }
+ return a;
+ }
+}
--- /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.yang.model.parser.util;
+
+import static org.hamcrest.core.Is.*;
+import static org.junit.Assert.*;
+
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.opendaylight.controller.yang.model.parser.util.TopologicalSort.Node;
+import org.opendaylight.controller.yang.model.parser.util.TopologicalSort.NodeImpl;
+
+import com.google.common.collect.Sets;
+
+public class TopologicalSortTest {
+
+ @Test(expected = IllegalStateException.class)
+ public void test() throws Exception {
+ Set<Node> nodes = Sets.newHashSet();
+
+ NodeImpl node1 = new NodeImpl();
+ nodes.add(node1);
+ NodeImpl node2 = new NodeImpl();
+ nodes.add(node2);
+ NodeImpl node3 = new NodeImpl();
+ nodes.add(node3);
+
+ node1.addEdge(node2);
+ node2.addEdge(node3);
+ node3.addEdge(node1);
+
+ try {
+ TopologicalSort.sort(nodes);
+ } catch (IllegalStateException e) {
+ throw e;
+ }
+ }
+
+ @Test
+ public void testValidSimple() throws Exception {
+ Set<Node> nodes = Sets.newHashSet();
+
+ Node node1 = new NodeImpl();
+ nodes.add(node1);
+ Node node2 = new NodeImpl();
+ nodes.add(node2);
+ Node node3 = new NodeImpl();
+ nodes.add(node3);
+ Node node4 = new NodeImpl();
+ nodes.add(node4);
+
+ ((NodeImpl) node1).addEdge(node2);
+ ((NodeImpl) node1).addEdge(node3);
+ ((NodeImpl) node2).addEdge(node4);
+ ((NodeImpl) node3).addEdge(node2);
+
+ List<Node> sorted = TopologicalSort.sort(nodes);
+
+ assertThat(sorted.get(0), is(node4));
+ assertThat(sorted.get(1), is(node2));
+ assertThat(sorted.get(2), is(node3));
+ assertThat(sorted.get(3), is(node1));
+ }
+
+}
namespace "urn:simple.types.data.demo";
prefix "t2";
- import types1 {
- prefix "if";
- revision-date 2013-02-27;
- }
-
organization "opendaylight";
contact "http://www.opendaylight.org/";
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"\r
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">\r
- <modelVersion>4.0.0</modelVersion>\r
- <groupId>org.opendaylight.controller</groupId>\r
- <artifactId>sal</artifactId>\r
- <version>1.0-SNAPSHOT</version>\r
- <packaging>pom</packaging>\r
-\r
- <modules>\r
- <module>sal-common</module>\r
- <module>sal-common-util</module>\r
- <module>sal-core-api</module>\r
- <module>sal-data-api</module>\r
- <module>sal-binding-api</module>\r
- <module>sal-binding-spi</module>\r
- <module>sal-binding-broker-impl</module>\r
- <module>sal-schema-repository-api</module>\r
- <module>sal-core-spi</module>\r
- <module>sal-broker-impl</module>\r
- <module>sal-core-demo</module>\r
- </modules>\r
-\r
- <dependencyManagement>\r
- <dependencies>\r
- <dependency>\r
- <groupId>com.google.guava</groupId>\r
- <artifactId>guava</artifactId>\r
- <version>14.0.1</version>\r
- <type>jar</type>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.slf4j</groupId>\r
- <artifactId>slf4j-api</artifactId>\r
- <version>1.7.2</version>\r
- </dependency>\r
- <dependency>\r
- <groupId>junit</groupId>\r
- <artifactId>junit</artifactId>\r
- <version>4.10</version>\r
- </dependency>\r
- </dependencies>\r
- </dependencyManagement>\r
-\r
- <dependencies>\r
- <dependency>\r
- <groupId>junit</groupId>\r
- <artifactId>junit</artifactId>\r
- <scope>test</scope>\r
- <optional>true</optional>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.mockito</groupId>\r
- <artifactId>mockito-all</artifactId>\r
- <version>1.9.5</version>\r
- <scope>test</scope>\r
- </dependency>\r
- </dependencies>\r
- <build>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-compiler-plugin</artifactId>\r
- <version>2.0</version>\r
- <inherited>true</inherited>\r
- <configuration>\r
- <source>1.6</source>\r
- <target>1.6</target>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-javadoc-plugin</artifactId>\r
- <version>2.8.1</version>\r
- <configuration>\r
- <stylesheet>maven</stylesheet>\r
- </configuration>\r
- <executions>\r
- <execution>\r
- <goals>\r
- <goal>aggregate</goal>\r
- </goals>\r
- <phase>site</phase>\r
- </execution>\r
- </executions>\r
- </plugin>\r
- </plugins>\r
- </build>\r
- <reporting>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>findbugs-maven-plugin</artifactId>\r
- <version>2.4.0</version>\r
- <configuration>\r
- <effort>Max</effort>\r
- <threshold>Low</threshold>\r
- <goal>site</goal>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>jdepend-maven-plugin</artifactId>\r
- <version>2.0-beta-2</version>\r
- </plugin>\r
- </plugins>\r
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <packaging>pom</packaging>
+
+ <modules>
+ <module>sal-common</module>
+ <module>sal-common-util</module>
+ <module>sal-core-api</module>
+ <module>sal-data-api</module>
+ <module>sal-binding-api</module>
+ <module>sal-binding-spi</module>
+ <module>sal-binding-broker-impl</module>
+ <module>sal-schema-repository-api</module>
+ <module>sal-core-spi</module>
+ <module>sal-broker-impl</module>
+ <module>sal-core-demo</module>
+ </modules>
+
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ <version>14.0.1</version>
+ <type>jar</type>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>1.7.2</version>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.10</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <version>1.9.5</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>2.0</version>
+ <inherited>true</inherited>
+ <configuration>
+ <source>1.7</source>
+ <target>1.7</target>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.8.1</version>
+ <configuration>
+ <stylesheet>maven</stylesheet>
+ </configuration>
+ <executions>
+ <execution>
+ <goals>
+ <goal>aggregate</goal>
+ </goals>
+ <phase>site</phase>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <reporting>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>findbugs-maven-plugin</artifactId>
+ <version>2.4.0</version>
+ <configuration>
+ <effort>Max</effort>
+ <threshold>Low</threshold>
+ <goal>site</goal>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>jdepend-maven-plugin</artifactId>
+ <version>2.0-beta-2</version>
+ </plugin>
+ </plugins>
</reporting>
</project>
\ No newline at end of file
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">\r
- <modelVersion>4.0.0</modelVersion>\r
- <groupId>org.opendaylight.controller</groupId>\r
- <artifactId>yang</artifactId>\r
- <version>1.0</version>\r
- <packaging>pom</packaging>\r
- <modules>\r
- <module>yang-common</module>\r
- <module>yang-data-api</module>\r
- <module>yang-data-util</module>\r
- <module>yang-model-api</module>\r
- <module>yang-model-util</module>\r
- <module>yang-binding</module>\r
- </modules>\r
- <dependencies>\r
-\r
- <dependency>\r
- <groupId>junit</groupId>\r
- <artifactId>junit</artifactId>\r
- <version>4.10</version>\r
- <scope>test</scope>\r
- <optional>true</optional>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.slf4j</groupId>\r
- <artifactId>slf4j-api</artifactId>\r
- <version>1.7.2</version>\r
- </dependency>\r
- <dependency>\r
- <groupId>org.slf4j</groupId>\r
- <artifactId>slf4j-simple</artifactId>\r
- <version>1.7.2</version>\r
- </dependency>\r
- </dependencies>\r
- <build>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-compiler-plugin</artifactId>\r
- <version>2.0</version>\r
- <inherited>true</inherited>\r
- <configuration>\r
- <source>1.6</source>\r
- <target>1.6</target>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.apache.maven.plugins</groupId>\r
- <artifactId>maven-javadoc-plugin</artifactId>\r
- <version>2.8.1</version>\r
- <configuration>\r
- <stylesheet>maven</stylesheet>\r
- </configuration>\r
- <executions>\r
- <execution>\r
- <goals>\r
- <goal>aggregate</goal>\r
- </goals>\r
- <phase>site</phase>\r
- </execution>\r
- </executions>\r
- </plugin>\r
- </plugins>\r
- </build>\r
- <reporting>\r
- <plugins>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>findbugs-maven-plugin</artifactId>\r
- <version>2.4.0</version>\r
- <configuration>\r
- <effort>Max</effort>\r
- <threshold>Low</threshold>\r
- <goal>site</goal>\r
- </configuration>\r
- </plugin>\r
- <plugin>\r
- <groupId>org.codehaus.mojo</groupId>\r
- <artifactId>jdepend-maven-plugin</artifactId>\r
- <version>2.0-beta-2</version>\r
- </plugin>\r
- </plugins>\r
- </reporting>\r
-</project>\r
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>yang</artifactId>
+ <version>1.0</version>
+ <packaging>pom</packaging>
+ <modules>
+ <module>yang-common</module>
+ <module>yang-data-api</module>
+ <module>yang-data-util</module>
+ <module>yang-model-api</module>
+ <module>yang-model-util</module>
+ <module>yang-binding</module>
+ </modules>
+ <dependencies>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.10</version>
+ <scope>test</scope>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>1.7.2</version>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-simple</artifactId>
+ <version>1.7.2</version>
+ </dependency>
+ </dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>2.0</version>
+ <inherited>true</inherited>
+ <configuration>
+ <source>1.7</source>
+ <target>1.7</target>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.8.1</version>
+ <configuration>
+ <stylesheet>maven</stylesheet>
+ </configuration>
+ <executions>
+ <execution>
+ <goals>
+ <goal>aggregate</goal>
+ </goals>
+ <phase>site</phase>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <reporting>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>findbugs-maven-plugin</artifactId>
+ <version>2.4.0</version>
+ <configuration>
+ <effort>Max</effort>
+ <threshold>Low</threshold>
+ <goal>site</goal>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>jdepend-maven-plugin</artifactId>
+ <version>2.0-beta-2</version>
+ </plugin>
+ </plugins>
+ </reporting>
+</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</plugin>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
mavenBundle("ch.qos.logback", "logback-classic", "1.0.9"),
// List all the bundles on which the test case depends
mavenBundle("org.opendaylight.controller", "sal",
- "0.4.0-SNAPSHOT"),
+ "0.5.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller",
"sal.implementation", "0.4.0-SNAPSHOT"),
mavenBundle("org.opendaylight.controller", "statisticsmanager",
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
import org.opendaylight.controller.switchmanager.Subnet;
/**
- * The interface class provides methods to notify listeners about subnet and
- * mode changes.
+ * The interface provides methods to notify listeners about subnet and mode
+ * changes.
*/
public interface ISwitchManagerAware {
/**
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.controller.sal.utils.Status;
/**
- * Interface class that provides methods to interact with
- * network topology database
+ * The Interface provides methods to interact with network topology database.
*/
public interface ITopologyManager {
/**
import org.slf4j.LoggerFactory;
/**
- * Interface class that provides methods to manipulate user configured link
+ * The Interface provides methods to manipulate user configured link.
*/
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
+import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.controller.sal.core.Node.NodeIDType;
import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
import org.opendaylight.controller.sal.topology.ITopologyService;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
private static String ROOT = GlobalConstants.STARTUPHOME.toString();
private String userLinksFileName = null;
private ConcurrentMap<String, TopologyUserLinkConfig> userLinks;
-
+
void nonClusterObjectCreate() {
- edgesDB = new ConcurrentHashMap<Edge, Set<Property>>();
- hostsDB = new ConcurrentHashMap<NodeConnector, ImmutablePair<Host, Set<Property>>>();
- userLinks = new ConcurrentHashMap<String, TopologyUserLinkConfig>();
- nodeConnectorsDB = new ConcurrentHashMap<NodeConnector, Set<Property>>();
+ edgesDB = new ConcurrentHashMap<Edge, Set<Property>>();
+ hostsDB = new ConcurrentHashMap<NodeConnector, ImmutablePair<Host, Set<Property>>>();
+ userLinks = new ConcurrentHashMap<String, TopologyUserLinkConfig>();
+ nodeConnectorsDB = new ConcurrentHashMap<NodeConnector, Set<Property>>();
}
-
void setTopologyManagerAware(ITopologyManagerAware s) {
if (this.topologyManagerAware != null) {
- log.debug("Adding ITopologyManagerAware: {}", s);
+ log.debug("Adding ITopologyManagerAware: {}", s);
this.topologyManagerAware.add(s);
}
}
void unsetTopologyManagerAware(ITopologyManagerAware s) {
if (this.topologyManagerAware != null) {
- log.debug("Removing ITopologyManagerAware: {}", s);
+ log.debug("Removing ITopologyManagerAware: {}", s);
this.topologyManagerAware.remove(s);
}
}
void setTopoService(ITopologyService s) {
- log.debug("Adding ITopologyService: {}", s);
+ log.debug("Adding ITopologyService: {}", s);
this.topoService = s;
}
void unsetTopoService(ITopologyService s) {
if (this.topoService == s) {
- log.debug("Removing ITopologyService: {}", s);
+ log.debug("Removing ITopologyService: {}", s);
this.topoService = null;
}
}
/**
* Function called by the dependency manager when all the required
* dependencies are satisfied
- *
+ *
*/
void init(Component c) {
String containerName = null;
}
/**
- * Function called after the topology manager has registered the
- * service in OSGi service registry.
- *
+ * Function called after the topology manager has registered the service in
+ * OSGi service registry.
+ *
*/
void started() {
// SollicitRefresh MUST be called here else if called at init
}
/**
- * Function called by the dependency manager when at least one
- * dependency become unsatisfied or when the component is shutting
- * down because for example bundle is being stopped.
- *
+ * Function called by the dependency manager when at least one dependency
+ * become unsatisfied or when the component is shutting down because for
+ * example bundle is being stopped.
+ *
*/
void destroy() {
if (this.clusterContainerService == null) {
// Publish the save config event to the cluster nodes
/**
* Get the CLUSTERING SERVICES WORKING BEFORE TRYING THIS
-
- configSaveEvent.put(new Date().getTime(), SAVE);
+ *
+ * configSaveEvent.put(new Date().getTime(), SAVE);
*/
return saveConfigInternal();
}
public Status saveConfigInternal() {
- Status retS;
+ Status retS;
ObjectWriter objWriter = new ObjectWriter();
- retS = objWriter.write(
- new ConcurrentHashMap<String, TopologyUserLinkConfig>(
+ retS = objWriter
+ .write(new ConcurrentHashMap<String, TopologyUserLinkConfig>(
userLinks), userLinksFileName);
if (retS.isSuccess()) {
}
/**
- * The Map returned is a copy of the current topology hence if the
- * topology changes the copy doesn't
- *
- * @return A Map representing the current topology expressed as
- * edges of the network
+ * The Map returned is a copy of the current topology hence if the topology
+ * changes the copy doesn't
+ *
+ * @return A Map representing the current topology expressed as edges of the
+ * network
*/
@Override
public Map<Edge, Set<Property>> getEdges() {
for (Edge key : this.edgesDB.keySet()) {
// Sets of props are copied because the composition of
// those properties could change with time
- HashSet<Property> prop = new HashSet<Property>(this.edgesDB
- .get(key));
+ HashSet<Property> prop = new HashSet<Property>(
+ this.edgesDB.get(key));
// We can simply reuse the key because the object is
// immutable so doesn't really matter that we are
// referencing the only owned by a different table, the
// TODO remove with spring-dm removal
/**
- * @param set the topologyAware to set
+ * @param set
+ * the topologyAware to set
*/
public void setTopologyAware(Set<Object> set) {
for (Object s : set) {
if (this.hostsDB == null) {
return;
}
-
+
switch (t) {
case ADDED:
case CHANGED:
}
}
- @Override
- public void edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
+ private TopoEdgeUpdate edgeUpdate(Edge e, UpdateType type,
+ Set<Property> props) {
switch (type) {
case ADDED:
// Make sure the props are non-null
props = (Set<Property>) new HashSet(props);
}
- // Now make sure thre is the creation timestamp for the
+ // Now make sure there is the creation timestamp for the
// edge, if not there timestamp with the first update
boolean found_create = false;
for (Property prop : props) {
}
}
- // Now lest make sure new properties are non-null
+ // Now lets make sure new properties are non-null
// Make sure the props are non-null
if (props == null) {
props = (Set<Property>) new HashSet();
log.trace("Edge {} {}", e.toString(), type.name());
break;
}
+ return new TopoEdgeUpdate(e, props, type);
+ }
+
+ @Override
+ public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
+ List<TopoEdgeUpdate> teuList = new ArrayList<TopoEdgeUpdate>();
+ 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();
+ TopoEdgeUpdate teu = edgeUpdate(e, type, p);
+ teuList.add(teu);
+ }
// Now update the listeners
for (ITopologyManagerAware s : this.topologyManagerAware) {
try {
- s.edgeUpdate(e, type, props);
+ s.edgeUpdate(teuList);
} catch (Exception exc) {
log.error("Exception on callback", exc);
}
}
+
}
private Edge getReverseLinkTuple(TopologyUserLinkConfig link) {
- TopologyUserLinkConfig rLink = new TopologyUserLinkConfig(
- link.getName(), link.getDstNodeIDType(), link.getDstSwitchId(),
- link.getDstNodeConnectorIDType(), link.getDstPort(),
- link.getSrcNodeIDType(), link.getSrcSwitchId(),
- link.getSrcNodeConnectorIDType(), link.getSrcPort());
+ TopologyUserLinkConfig rLink = new TopologyUserLinkConfig(
+ link.getName(), link.getDstNodeIDType(), link.getDstSwitchId(),
+ link.getDstNodeConnectorIDType(), link.getDstPort(),
+ link.getSrcNodeIDType(), link.getSrcSwitchId(),
+ link.getSrcNodeConnectorIDType(), link.getSrcPort());
return getLinkTuple(rLink);
}
private Edge getLinkTuple(TopologyUserLinkConfig link) {
Edge linkTuple = null;
- // if atleast 1 link exists for the srcPort and atleast 1 link exists for the dstPort
+ // if atleast 1 link exists for the srcPort and atleast 1 link exists
+ // for the dstPort
// that makes it ineligible for the Manual link addition
// This is just an extra protection to avoid mis-programming.
boolean srcLinkExists = false;
boolean dstLinkExists = false;
- //TODO check a way to validate the port with inventory services
- //if (srcSw.getPorts().contains(srcPort) &&
- //dstSw.getPorts().contains(srcPort) &&
+ // TODO check a way to validate the port with inventory services
+ // if (srcSw.getPorts().contains(srcPort) &&
+ // dstSw.getPorts().contains(srcPort) &&
if (!srcLinkExists && !dstLinkExists) {
Node sNode = null;
Node dNode = null;
String dstNodeIDType = link.getDstNodeIDType();
String dstNodeConnectorIDType = link.getDstNodeConnectorIDType();
try {
- if (srcNodeIDType.equals(NodeIDType.OPENFLOW)) {
+ if (srcNodeIDType.equals(NodeIDType.OPENFLOW)) {
sNode = new Node(srcNodeIDType, link.getSrcSwitchIDLong());
- } else {
- sNode = new Node(srcNodeIDType, link.getSrcSwitchId());
- }
+ } else {
+ sNode = new Node(srcNodeIDType, link.getSrcSwitchId());
+ }
- if (dstNodeIDType.equals(NodeIDType.OPENFLOW)) {
+ if (dstNodeIDType.equals(NodeIDType.OPENFLOW)) {
dNode = new Node(dstNodeIDType, link.getDstSwitchIDLong());
- } else {
- dNode = new Node(dstNodeIDType, link.getDstSwitchId());
- }
-
- if (srcNodeConnectorIDType.equals(NodeConnectorIDType.OPENFLOW)) {
+ } else {
+ dNode = new Node(dstNodeIDType, link.getDstSwitchId());
+ }
+
+ if (srcNodeConnectorIDType.equals(NodeConnectorIDType.OPENFLOW)) {
Short srcPort = Short.valueOf((short) 0);
- if (!link.isSrcPortByName()) {
- srcPort = Short.parseShort(link.getSrcPort());
- }
- sPort = new NodeConnector(srcNodeConnectorIDType,
- srcPort, sNode);
- } else {
- sPort = new NodeConnector(srcNodeConnectorIDType,
- link.getSrcPort(), sNode);
- }
-
- if (dstNodeConnectorIDType.equals(NodeConnectorIDType.OPENFLOW)) {
+ if (!link.isSrcPortByName()) {
+ srcPort = Short.parseShort(link.getSrcPort());
+ }
+ sPort = new NodeConnector(srcNodeConnectorIDType, srcPort,
+ sNode);
+ } else {
+ sPort = new NodeConnector(srcNodeConnectorIDType,
+ link.getSrcPort(), sNode);
+ }
+
+ if (dstNodeConnectorIDType.equals(NodeConnectorIDType.OPENFLOW)) {
Short dstPort = Short.valueOf((short) 0);
- if (!link.isDstPortByName()) {
- dstPort = Short.parseShort(link.getDstPort());
- }
- dPort = new NodeConnector(dstNodeConnectorIDType,
- dstPort, dNode);
- } else {
- dPort = new NodeConnector(dstNodeConnectorIDType,
- link.getDstPort(), dNode);
- }
+ if (!link.isDstPortByName()) {
+ dstPort = Short.parseShort(link.getDstPort());
+ }
+ dPort = new NodeConnector(dstNodeConnectorIDType, dstPort,
+ dNode);
+ } else {
+ dPort = new NodeConnector(dstNodeConnectorIDType,
+ link.getDstPort(), dNode);
+ }
linkTuple = new Edge(sPort, dPort);
} catch (ConstructionException cex) {
- log.warn("Caught exception ", cex);
+ log.warn("Caught exception ", cex);
}
return linkTuple;
}
@Override
public Status addUserLink(TopologyUserLinkConfig link) {
if (!link.isValid()) {
- return new Status(StatusCode.BADREQUEST,
- "Configuration Invalid. Please check the parameters");
+ return new Status(StatusCode.BADREQUEST,
+ "Configuration Invalid. Please check the parameters");
}
if (userLinks.get(link.getName()) != null) {
- return new Status(StatusCode.CONFLICT,
- "Link with name : " + link.getName()
+ return new Status(StatusCode.CONFLICT, "Link with name : "
+ + link.getName()
+ " already exists. Please use another name");
}
if (userLinks.containsValue(link)) {
link.setStatus(TopologyUserLinkConfig.STATUS.SUCCESS);
} catch (Exception e) {
return new Status(StatusCode.INTERNALERROR,
- "Exception while adding custom link : " +
- e.getMessage());
+ "Exception while adding custom link : "
+ + e.getMessage());
}
}
return new Status(StatusCode.SUCCESS, null);
@Override
public Status deleteUserLink(String linkName) {
if (linkName == null) {
- return new Status(StatusCode.BADREQUEST,
- "A valid linkName is required to Delete a link");
+ return new Status(StatusCode.BADREQUEST,
+ "A valid linkName is required to Delete a link");
}
TopologyUserLinkConfig link = userLinks.get(linkName);
userLinks.remove(linkName);
if (linkTuple != null) {
try {
- //oneTopology.deleteUserConfiguredLink(linkTuple);
+ // oneTopology.deleteUserConfiguredLink(linkTuple);
} catch (Exception e) {
- log
- .warn("Harmless : Exception while Deleting User Configured link {} {}",
- link, e.toString());
+ log.warn(
+ "Harmless : Exception while Deleting User Configured link {} {}",
+ link, e.toString());
}
linkTuple = getReverseLinkTuple(link);
try {
- //oneTopology.deleteUserConfiguredLink(linkTuple);
+ // oneTopology.deleteUserConfiguredLink(linkTuple);
} catch (Exception e) {
- log
- .warn("Harmless : Exception while Deleting User Configured Reverse link {} {}",
- link, e.toString());
+ log.warn(
+ "Harmless : Exception while Deleting User Configured Reverse link {} {}",
+ link, e.toString());
}
}
return new Status(StatusCode.SUCCESS, null);
public String getHelp() {
StringBuffer help = new StringBuffer();
help.append("---Topology Manager---\n");
- help.append("\t addTopo name <NodeIDType> <src-sw-id> <NodeConnectorIDType> <port-number> <NodeIDType> <dst-sw-id> <NodeConnectorIDType> <port-number>\n");
+ help.append("\t addTopo name <NodeIDType> <src-sw-id> <NodeConnectorIDType> <port-number> <NodeIDType> <dst-sw-id> <NodeConnectorIDType> <port-number>\n");
help.append("\t delTopo name\n");
help.append("\t printTopo\n");
help.append("\t printNodeEdges\n");
public void _printTopo(CommandInterpreter ci) {
for (String name : this.userLinks.keySet()) {
- TopologyUserLinkConfig linkConfig = userLinks.get(name);
+ TopologyUserLinkConfig linkConfig = userLinks.get(name);
ci.println("Name : " + name);
ci.println(linkConfig);
- ci.println("Edge " + getLinkTuple(linkConfig));
- ci.println("Reverse Edge " + getReverseLinkTuple(linkConfig));
+ ci.println("Edge " + getLinkTuple(linkConfig));
+ ci.println("Reverse Edge " + getReverseLinkTuple(linkConfig));
}
}
ci.println("Null destination port number");
return;
}
- TopologyUserLinkConfig config = new TopologyUserLinkConfig(name,
- srcNodeIDType, dpid, srcNodeConnectorIDType, port,
- dstNodeIDType, ddpid, dstNodeConnectorIDType, dport);
+ TopologyUserLinkConfig config = new TopologyUserLinkConfig(name,
+ srcNodeIDType, dpid, srcNodeConnectorIDType, port,
+ dstNodeIDType, ddpid, dstNodeConnectorIDType, dport);
ci.println(this.addUserLink(config));
}
}
public void _printNodeEdges(CommandInterpreter ci) {
- Map<Node, Set<Edge>> nodeEdges = getNodeEdges();
- if (nodeEdges == null) {
- return;
- }
- Set<Node> nodeSet = nodeEdges.keySet();
- if (nodeSet == null) {
- return;
- }
+ Map<Node, Set<Edge>> nodeEdges = getNodeEdges();
+ if (nodeEdges == null) {
+ return;
+ }
+ Set<Node> nodeSet = nodeEdges.keySet();
+ if (nodeSet == null) {
+ return;
+ }
ci.println(" Node Edge");
- for (Node node : nodeSet) {
- Set<Edge> edgeSet = nodeEdges.get(node);
- if (edgeSet == null) {
- continue;
- }
- for (Edge edge : edgeSet) {
- ci.println(node + " " + edge);
- }
+ for (Node node : nodeSet) {
+ Set<Edge> edgeSet = nodeEdges.get(node);
+ if (edgeSet == null) {
+ continue;
+ }
+ for (Edge edge : edgeSet) {
+ ci.println(node + " " + edge);
+ }
}
}
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.controller.sal.core.State;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.packet.address.EthernetAddress;
+import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
import org.opendaylight.controller.sal.utils.NodeCreator;
import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
-public class TopologyManagerImplTest {
-
- /*
- * Sets the node, edges and properties for edges here:
- * Edge <SwitchId : NodeConnectorId> :
- * <1:1>--><11:11>; <1:2>--><11:12>;
- * <3:3>--><13:13>; <3:4>--><13:14>;
- * <5:5>--><15:15>; <5:6>--><15:16>;
- * Method used by two tests: testGetNodeEdges and testGetEdges
- * @param topoManagerImpl
- * @throws ConstructionException
- */
- public void setNodeEdges(TopologyManagerImpl topoManagerImpl) throws ConstructionException {
- topoManagerImpl.nonClusterObjectCreate();
-
- State state;
- Bandwidth bw;
- Latency l;
-
- Set<Property> props = new HashSet<Property>();
- state = new State(State.EDGE_UP);
- bw = new Bandwidth(Bandwidth.BW100Gbps);
- l = new Latency(Latency.LATENCY100ns);
- props.add(state);
- props.add(bw);
- props.add(l);
-
- for (short i = 1; i < 6; i=(short) (i+2)) {
- NodeConnector headnc1 = NodeConnectorCreator.createOFNodeConnector(i, NodeCreator.createOFNode((long)i));
- NodeConnector tailnc1 = NodeConnectorCreator.createOFNodeConnector((short)(i+10), NodeCreator.createOFNode((long)(i+10)));
- Edge e1 = new Edge(headnc1, tailnc1);
- topoManagerImpl.edgeUpdate(e1, UpdateType.ADDED, props);
-
- NodeConnector headnc2 = NodeConnectorCreator.createOFNodeConnector((short) (i+1), headnc1.getNode());
- NodeConnector tailnc2 = NodeConnectorCreator.createOFNodeConnector((short)(i+11), tailnc1.getNode());
- Edge e2 = new Edge(headnc2, tailnc2);
- topoManagerImpl.edgeUpdate(e2, UpdateType.ADDED, props);
- }
- }
-
- @Test
- public void testGetNodeEdges() throws ConstructionException {
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- setNodeEdges(topoManagerImpl);
-
- Map<Node, Set<Edge>> nodeEdgeMap = topoManagerImpl.getNodeEdges();
- for (Iterator<Map.Entry<Node,Set<Edge>>> i = nodeEdgeMap.entrySet().iterator(); i.hasNext();) {
- Map.Entry<Node, Set<Edge>> entry = i.next();
- Node node = entry.getKey();
- Long nodeId = ((Long) node.getID()).longValue();
- Assert.assertTrue((node.getType().equals(NodeIDType.OPENFLOW)));
-
- Set<Edge> edges = entry.getValue();
- for (Edge edge : edges) {
- Long headNcId = ((Short)edge.getHeadNodeConnector().getID()).longValue();
- Long tailNcId = ((Short) edge.getTailNodeConnector().getID()).longValue();
- if (nodeId == 1 || nodeId == 3 || nodeId == 5) {
- Assert.assertTrue((headNcId.equals(nodeId) && tailNcId.equals(nodeId + 10)) ||
- (headNcId.equals(nodeId + 10) && tailNcId.equals(nodeId)) ||
- (headNcId.equals(nodeId + 1) && tailNcId.equals(nodeId + 11)) ||
- (headNcId.equals(nodeId + 11) && tailNcId.equals(nodeId + 1)));
- } else if (nodeId == 11 || nodeId == 13 || nodeId == 15) {
- Assert.assertTrue((headNcId.equals(nodeId) && tailNcId.equals(nodeId - 10)) ||
- (headNcId.equals(nodeId) && tailNcId.equals(nodeId - 10)) ||
- (headNcId.equals(nodeId - 9) && tailNcId.equals(nodeId + 1)) ||
- (headNcId.equals(nodeId + 1) && tailNcId.equals(nodeId - 9)));
- }
- }
- i.remove();
- }
- Assert.assertTrue(nodeEdgeMap.isEmpty());
- }
-
- @Test
- public void testGetEdges() throws ConstructionException {
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- setNodeEdges(topoManagerImpl);
-
- Map<Edge, Set<Property>> edgeProperty = topoManagerImpl.getEdges();
-
- for (Iterator <Map.Entry<Edge, Set<Property>>> i = edgeProperty.entrySet().iterator() ; i.hasNext();) {
- Map.Entry<Edge, Set<Property>> entry = i.next();
- Edge e = entry.getKey();
- NodeConnector headnc = e.getHeadNodeConnector();
- NodeConnector tailnc = e.getTailNodeConnector();
-
- Long headNodeId = (Long) headnc.getNode().getID();
-
- Long headNcId = ((Short)headnc.getID()).longValue();
- Long tailNcId = ((Short)tailnc.getID()).longValue();
-
- if (headNodeId == 1 || headNodeId == 3 || headNodeId == 5) {
- Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId.equals(headNodeId + 10)) ||
- (headNcId.equals(headNodeId + 10) && tailNcId.equals(headNodeId)) ||
- (headNcId.equals(headNodeId + 1) && tailNcId.equals(headNodeId + 11)) ||
- (headNcId.equals(headNodeId + 11) && tailNcId.equals(headNodeId + 1)));
- } else if (headNodeId == 11 || headNodeId == 13 || headNodeId == 15) {
- Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId.equals(headNodeId - 10)) ||
- (headNcId.equals(headNodeId) && tailNcId.equals(headNodeId - 10)) ||
- (headNcId.equals(headNodeId - 9) && tailNcId.equals(headNodeId + 1)) ||
- (headNcId.equals(headNodeId + 1) && tailNcId.equals(headNodeId - 9)));
- }
-
- Set<Property> prop = entry.getValue();
- for (Property p : prop) {
- String pName;
- long pValue;
- if (p instanceof Bandwidth) {
- Bandwidth b = (Bandwidth)p;
- pName = Bandwidth.BandwidthPropName;
- pValue = b.getValue();
- Assert.assertTrue(pName.equals(p.getName()) && pValue == Bandwidth.BW100Gbps );
- continue;
- }
- if (p instanceof Latency) {
- Latency l = (Latency)p;
- pName = Latency.LatencyPropName;
- pValue = l.getValue();
- Assert.assertTrue(pName.equals(p.getName()) && pValue == Latency.LATENCY100ns);
- continue;
- }
- if (p instanceof State) {
- State state = (State)p;
- pName = State.StatePropName;
- pValue = state.getValue();
- Assert.assertTrue(pName.equals(p.getName()) && pValue == State.EDGE_UP);
- continue;
- }
- }
- i.remove();
- }
- Assert.assertTrue(edgeProperty.isEmpty());
- }
-
-
- @Test
- public void testAddDeleteUserLink () {
- TopologyUserLinkConfig link1 = new TopologyUserLinkConfig("default1", "OF", "1", "OF", "2", "OF", "1", "OF", "2");
- TopologyUserLinkConfig link2 = new TopologyUserLinkConfig("default1", "OF", "10", "OF", "20", "OF", "10", "OF", "20");
- TopologyUserLinkConfig link3 = new TopologyUserLinkConfig("default2", "OF", "1", "OF", "2", "OF", "1", "OF", "2");
- TopologyUserLinkConfig link4 = new TopologyUserLinkConfig("default20", "OF", "10", "OF", "20", "OF", "10", "OF", "20");
-
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- topoManagerImpl.nonClusterObjectCreate();
-
- Assert.assertTrue (topoManagerImpl.addUserLink(link1).isSuccess());
- Assert.assertTrue (topoManagerImpl.addUserLink(link2).getCode() == StatusCode.CONFLICT);
- Assert.assertTrue (topoManagerImpl.addUserLink(link3).getCode() == StatusCode.CONFLICT);
- Assert.assertTrue (topoManagerImpl.addUserLink(link4).isSuccess());
-
- Assert.assertTrue (topoManagerImpl.deleteUserLink(null).getCode() == StatusCode.BADREQUEST);
- Assert.assertTrue (topoManagerImpl.deleteUserLink(link1.getName()).isSuccess());
- Assert.assertTrue (topoManagerImpl.deleteUserLink(link4.getName()).isSuccess());
- Assert.assertTrue (topoManagerImpl.getUserLinks().isEmpty());
-
- }
-
- @Test
- public void testGetUserLink () {
- TopologyUserLinkConfig[] link = new TopologyUserLinkConfig[5];
- TopologyUserLinkConfig[] reverseLink = new TopologyUserLinkConfig[5];
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- topoManagerImpl.nonClusterObjectCreate();
-
- String name = null;
- String srcNodeIDType = null;
- String srcSwitchId = null;
- String srcNodeConnectorIDType = null;
- String srcPort = null;
- String dstNodeIDType = null;
- String dstSwitchId = null;
- String dstNodeConnectorIDType = null;
- String dstPort = null;
-
- /*Creating userlinks and checking for their validity*/
- link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
- srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
- dstNodeConnectorIDType, dstPort);
- Assert.assertTrue(link[0].isValid() == false);
-
- srcSwitchId = "1";
- link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
- srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
- dstNodeConnectorIDType, dstPort);
- Assert.assertTrue(link[0].isValid() == false);
-
- dstSwitchId = "2";
- link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
- srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
- dstNodeConnectorIDType, dstPort);
- Assert.assertTrue(link[0].isValid() == false);
-
-
- Integer i;
-
- for (i = 0; i < 5; i++) {
- link[i] = new TopologyUserLinkConfig(name, srcNodeIDType,
- srcSwitchId, srcNodeConnectorIDType, srcPort,
- dstNodeIDType, dstSwitchId, dstNodeConnectorIDType, dstPort);
-
- name = Integer.toString(i + 1);
- srcSwitchId = Integer.toString(i + 1);
- srcPort = Integer.toString(i + 1);
- dstSwitchId = Integer.toString((i + 1)*10);
- dstPort = Integer.toString((i + 1)*10);
-
- link[i].setName(name);
- link[i].setSrcSwitchId(srcSwitchId);
- link[i].setSrcPort(srcPort);
- link[i].setDstSwitchId(dstSwitchId);
- link[i].setDstPort(dstPort);
-
- Assert.assertTrue(link[i].isValid() == false);
-
- link[i].setSrcNodeIDType("OF");
- link[i].setSrcNodeConnectorIDType("OF");
-
- Assert.assertTrue(link[i].isValid() == false);
-
- link[i].setDstNodeIDType("OF");
- link[i].setDstNodeConnectorIDType("OF");
-
- Assert.assertTrue(link[i].isValid() == true);
-
- reverseLink[i] = new TopologyUserLinkConfig(name, dstNodeIDType,
- dstSwitchId, dstNodeConnectorIDType, dstPort,
- srcNodeIDType, srcSwitchId, srcNodeConnectorIDType, srcPort);
-
- topoManagerImpl.addUserLink(link[i]);
- }
- ConcurrentMap<String, TopologyUserLinkConfig> userLinks = topoManagerImpl.getUserLinks();
- TopologyUserLinkConfig resultLink;
-
- for (i = 0; i < 5; i++) {
- resultLink = userLinks.get(((Integer)(i + 1)).toString());
-
- Assert.assertTrue(resultLink.getName().equals(reverseLink[i].getName()));
- Assert.assertTrue(resultLink.getDstSwitchId().equals(reverseLink[i].getSrcSwitchId()));
- Assert.assertTrue(resultLink.getDstPort().equals(reverseLink[i].getSrcPort()));
- Assert.assertTrue(resultLink.getSrcSwitchId().equals(reverseLink[i].getDstSwitchId()));
- Assert.assertTrue(resultLink.getSrcPort().equals(reverseLink[i].getDstPort()));
- }
- }
-
- @Test
- public void testHostLinkMethods() throws ConstructionException, UnknownHostException {
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- topoManagerImpl.nonClusterObjectCreate();
- int hostCounter = 0;
-
- State state;
- Bandwidth bw;
- Latency l;
- Set<Property> props = new HashSet<Property>();
- state = new State(State.EDGE_UP);
- bw = new Bandwidth(Bandwidth.BW100Gbps);
- l = new Latency(Latency.LATENCY100ns);
- props.add(state);
- props.add(bw);
- props.add(l);
-
- EthernetAddress ea;
- InetAddress ip;
- Host[] h = new Host[5];
- NodeConnector[] nc = new NodeConnector[5];
-
- /* Adding host, nodeConnector to hostsDB for the i = 0,1,2,3. No host
- * added for i = 4
- */
- for (int i = 0; i < 5; i++) {
- if (hostCounter < 4) {
- ea = new EthernetAddress(new byte[]{(byte)0x0, (byte)0x0,
- (byte)0x0, (byte)0x0,
- (byte)0x0, (byte)i});
- String stringIP = new StringBuilder().append(i + 1).append(".").append(i+10).append(".").append(i+20).append(".").append(i+30).toString();
- ip = InetAddress.getByName(stringIP);
- h[hostCounter] = new Host(ea, ip);
- } else {
- h[hostCounter] = null;
- }
- hostCounter++;
- nc[i] = NodeConnectorCreator.createOFNodeConnector((short)(i + 1), NodeCreator.createOFNode((long)(i + 1)));
- topoManagerImpl.updateHostLink(nc[i], h[i], UpdateType.ADDED, props);
- }
-
- for (int i = 0; i < 5; i++) {
- Host host = topoManagerImpl.getHostAttachedToNodeConnector(nc[i]);
- if (i == 4)
- Assert.assertTrue(host == null);
- else
- Assert.assertTrue(host.equals(h[i]));
- }
-
- Set<NodeConnector> ncSet = topoManagerImpl.getNodeConnectorWithHost();
- for (int i = 0; i < 5; i++) {
- Assert.assertTrue(ncSet.remove(nc[i]));
- }
- Assert.assertTrue(ncSet.isEmpty());
- }
-
- @Test
- public void testGetNodesWithNodeConnectorHost() throws ConstructionException, UnknownHostException {
- TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- topoManagerImpl.nonClusterObjectCreate();
- int hostCounter = 0;
-
- State state;
- Bandwidth bw;
- Latency l;
- Set<Property> props = new HashSet<Property>();
- state = new State(State.EDGE_UP);
- bw = new Bandwidth(Bandwidth.BW100Gbps);
- l = new Latency(Latency.LATENCY100ns);
- props.add(state);
- props.add(bw);
- props.add(l);
-
- EthernetAddress ea;
- InetAddress ip;
- Host[] h = new Host[5];
- NodeConnector[] nc = new NodeConnector[5];
-
- /*Adding host, nodeconnector, properties of edge to hostsDB for the first three nodes only*/
- for (int i = 1; i < 6; i++) {
- if (i < 4) {
- ea = new EthernetAddress(new byte[]{(byte)0x0, (byte)0x0,
- (byte)0x0, (byte)0x0,
- (byte)0x0, (byte)i});
- String stringIP = new StringBuilder().append(i).append(".").append(i+10).append(".").append(i+20).append(".").append(i+30).toString();
- ip = InetAddress.getByName(stringIP);
- h[hostCounter] = new Host(ea, ip);
- }
- else {
- h[hostCounter] = null;
- }
- hostCounter++;
- nc[i - 1] = NodeConnectorCreator.createOFNodeConnector((short)i, NodeCreator.createOFNode((long)i));
- topoManagerImpl.updateHostLink(nc[i - 1], h[i - 1], UpdateType.ADDED, props);
- }
-
- /*Get the nodes which have host connected to its nodeConnector*/
- Map<Node, Set<NodeConnector>> nodeNCmap = topoManagerImpl.getNodesWithNodeConnectorHost();
- for (int i = 1; i < 6; i++) {
- Node node = nc[i - 1].getNode();
- Set<NodeConnector> ncSet = nodeNCmap.get(nc[i - 1].getNode());
-
- Assert.assertTrue(ncSet == nodeNCmap.remove(node));
- }
-
- Assert.assertTrue(nodeNCmap.isEmpty());
- }
-}
+public class TopologyManagerImplTest {
+
+ /*
+ * Sets the node, edges and properties for edges here: Edge <SwitchId :
+ * NodeConnectorId> : <1:1>--><11:11>; <1:2>--><11:12>; <3:3>--><13:13>;
+ * <3:4>--><13:14>; <5:5>--><15:15>; <5:6>--><15:16>; Method used by two
+ * tests: testGetNodeEdges and testGetEdges
+ *
+ * @param topoManagerImpl
+ *
+ * @throws ConstructionException
+ */
+ public void setNodeEdges(TopologyManagerImpl topoManagerImpl)
+ throws ConstructionException {
+ topoManagerImpl.nonClusterObjectCreate();
+
+ State state;
+ Bandwidth bw;
+ Latency l;
+
+ Set<Property> props = new HashSet<Property>();
+ state = new State(State.EDGE_UP);
+ bw = new Bandwidth(Bandwidth.BW100Gbps);
+ l = new Latency(Latency.LATENCY100ns);
+ props.add(state);
+ props.add(bw);
+ props.add(l);
+
+ for (short i = 1; i < 6; i = (short) (i + 2)) {
+ List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
+ NodeConnector headnc1 = NodeConnectorCreator.createOFNodeConnector(
+ i, NodeCreator.createOFNode((long) i));
+ NodeConnector tailnc1 = NodeConnectorCreator
+ .createOFNodeConnector((short) (i + 10),
+ NodeCreator.createOFNode((long) (i + 10)));
+ Edge e1 = new Edge(headnc1, tailnc1);
+ TopoEdgeUpdate teu1 = new TopoEdgeUpdate(e1, props,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu1);
+
+ NodeConnector headnc2 = NodeConnectorCreator.createOFNodeConnector(
+ (short) (i + 1), headnc1.getNode());
+ NodeConnector tailnc2 = NodeConnectorCreator.createOFNodeConnector(
+ (short) (i + 11), tailnc1.getNode());
+ Edge e2 = new Edge(headnc2, tailnc2);
+ TopoEdgeUpdate teu2 = new TopoEdgeUpdate(e2, props,
+ UpdateType.ADDED);
+ topoedgeupdateList.add(teu2);
+ topoManagerImpl.edgeUpdate(topoedgeupdateList);
+
+ }
+
+ }
+
+ @Test
+ public void testGetNodeEdges() throws ConstructionException {
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ setNodeEdges(topoManagerImpl);
+
+ Map<Node, Set<Edge>> nodeEdgeMap = topoManagerImpl.getNodeEdges();
+ for (Iterator<Map.Entry<Node, Set<Edge>>> i = nodeEdgeMap.entrySet()
+ .iterator(); i.hasNext();) {
+ Map.Entry<Node, Set<Edge>> entry = i.next();
+ Node node = entry.getKey();
+ Long nodeId = ((Long) node.getID()).longValue();
+ Assert.assertTrue((node.getType().equals(NodeIDType.OPENFLOW)));
+
+ Set<Edge> edges = entry.getValue();
+ for (Edge edge : edges) {
+ Long headNcId = ((Short) edge.getHeadNodeConnector().getID())
+ .longValue();
+ Long tailNcId = ((Short) edge.getTailNodeConnector().getID())
+ .longValue();
+ if (nodeId == 1 || nodeId == 3 || nodeId == 5) {
+ Assert.assertTrue((headNcId.equals(nodeId) && tailNcId
+ .equals(nodeId + 10))
+ || (headNcId.equals(nodeId + 10) && tailNcId
+ .equals(nodeId))
+ || (headNcId.equals(nodeId + 1) && tailNcId
+ .equals(nodeId + 11))
+ || (headNcId.equals(nodeId + 11) && tailNcId
+ .equals(nodeId + 1)));
+ } else if (nodeId == 11 || nodeId == 13 || nodeId == 15) {
+ Assert.assertTrue((headNcId.equals(nodeId) && tailNcId
+ .equals(nodeId - 10))
+ || (headNcId.equals(nodeId) && tailNcId
+ .equals(nodeId - 10))
+ || (headNcId.equals(nodeId - 9) && tailNcId
+ .equals(nodeId + 1))
+ || (headNcId.equals(nodeId + 1) && tailNcId
+ .equals(nodeId - 9)));
+ }
+ }
+ i.remove();
+ }
+ Assert.assertTrue(nodeEdgeMap.isEmpty());
+ }
+
+ @Test
+ public void testGetEdges() throws ConstructionException {
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ setNodeEdges(topoManagerImpl);
+
+ Map<Edge, Set<Property>> edgeProperty = topoManagerImpl.getEdges();
+
+ for (Iterator<Map.Entry<Edge, Set<Property>>> i = edgeProperty
+ .entrySet().iterator(); i.hasNext();) {
+ Map.Entry<Edge, Set<Property>> entry = i.next();
+ Edge e = entry.getKey();
+ NodeConnector headnc = e.getHeadNodeConnector();
+ NodeConnector tailnc = e.getTailNodeConnector();
+
+ Long headNodeId = (Long) headnc.getNode().getID();
+
+ Long headNcId = ((Short) headnc.getID()).longValue();
+ Long tailNcId = ((Short) tailnc.getID()).longValue();
+
+ if (headNodeId == 1 || headNodeId == 3 || headNodeId == 5) {
+ Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId
+ .equals(headNodeId + 10))
+ || (headNcId.equals(headNodeId + 10) && tailNcId
+ .equals(headNodeId))
+ || (headNcId.equals(headNodeId + 1) && tailNcId
+ .equals(headNodeId + 11))
+ || (headNcId.equals(headNodeId + 11) && tailNcId
+ .equals(headNodeId + 1)));
+ } else if (headNodeId == 11 || headNodeId == 13 || headNodeId == 15) {
+ Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId
+ .equals(headNodeId - 10))
+ || (headNcId.equals(headNodeId) && tailNcId
+ .equals(headNodeId - 10))
+ || (headNcId.equals(headNodeId - 9) && tailNcId
+ .equals(headNodeId + 1))
+ || (headNcId.equals(headNodeId + 1) && tailNcId
+ .equals(headNodeId - 9)));
+ }
+
+ Set<Property> prop = entry.getValue();
+ for (Property p : prop) {
+ String pName;
+ long pValue;
+ if (p instanceof Bandwidth) {
+ Bandwidth b = (Bandwidth) p;
+ pName = Bandwidth.BandwidthPropName;
+ pValue = b.getValue();
+ Assert.assertTrue(pName.equals(p.getName())
+ && pValue == Bandwidth.BW100Gbps);
+ continue;
+ }
+ if (p instanceof Latency) {
+ Latency l = (Latency) p;
+ pName = Latency.LatencyPropName;
+ pValue = l.getValue();
+ Assert.assertTrue(pName.equals(p.getName())
+ && pValue == Latency.LATENCY100ns);
+ continue;
+ }
+ if (p instanceof State) {
+ State state = (State) p;
+ pName = State.StatePropName;
+ pValue = state.getValue();
+ Assert.assertTrue(pName.equals(p.getName())
+ && pValue == State.EDGE_UP);
+ continue;
+ }
+ }
+ i.remove();
+ }
+ Assert.assertTrue(edgeProperty.isEmpty());
+ }
+
+ @Test
+ public void testAddDeleteUserLink() {
+ TopologyUserLinkConfig link1 = new TopologyUserLinkConfig("default1",
+ "OF", "1", "OF", "2", "OF", "1", "OF", "2");
+ TopologyUserLinkConfig link2 = new TopologyUserLinkConfig("default1",
+ "OF", "10", "OF", "20", "OF", "10", "OF", "20");
+ TopologyUserLinkConfig link3 = new TopologyUserLinkConfig("default2",
+ "OF", "1", "OF", "2", "OF", "1", "OF", "2");
+ TopologyUserLinkConfig link4 = new TopologyUserLinkConfig("default20",
+ "OF", "10", "OF", "20", "OF", "10", "OF", "20");
+
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ topoManagerImpl.nonClusterObjectCreate();
+
+ Assert.assertTrue(topoManagerImpl.addUserLink(link1).isSuccess());
+ Assert.assertTrue(topoManagerImpl.addUserLink(link2).getCode() == StatusCode.CONFLICT);
+ Assert.assertTrue(topoManagerImpl.addUserLink(link3).getCode() == StatusCode.CONFLICT);
+ Assert.assertTrue(topoManagerImpl.addUserLink(link4).isSuccess());
+
+ Assert.assertTrue(topoManagerImpl.deleteUserLink(null).getCode() == StatusCode.BADREQUEST);
+ Assert.assertTrue(topoManagerImpl.deleteUserLink(link1.getName())
+ .isSuccess());
+ Assert.assertTrue(topoManagerImpl.deleteUserLink(link4.getName())
+ .isSuccess());
+ Assert.assertTrue(topoManagerImpl.getUserLinks().isEmpty());
+
+ }
+
+ @Test
+ public void testGetUserLink() {
+ TopologyUserLinkConfig[] link = new TopologyUserLinkConfig[5];
+ TopologyUserLinkConfig[] reverseLink = new TopologyUserLinkConfig[5];
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ topoManagerImpl.nonClusterObjectCreate();
+
+ String name = null;
+ String srcNodeIDType = null;
+ String srcSwitchId = null;
+ String srcNodeConnectorIDType = null;
+ String srcPort = null;
+ String dstNodeIDType = null;
+ String dstSwitchId = null;
+ String dstNodeConnectorIDType = null;
+ String dstPort = null;
+
+ /* Creating userlinks and checking for their validity */
+ link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
+ srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
+ dstNodeConnectorIDType, dstPort);
+ Assert.assertTrue(link[0].isValid() == false);
+
+ srcSwitchId = "1";
+ link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
+ srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
+ dstNodeConnectorIDType, dstPort);
+ Assert.assertTrue(link[0].isValid() == false);
+ dstSwitchId = "2";
+ link[0] = new TopologyUserLinkConfig(name, srcNodeIDType, srcSwitchId,
+ srcNodeConnectorIDType, srcPort, dstNodeIDType, dstSwitchId,
+ dstNodeConnectorIDType, dstPort);
+ Assert.assertTrue(link[0].isValid() == false);
+
+ Integer i;
+
+ for (i = 0; i < 5; i++) {
+ link[i] = new TopologyUserLinkConfig(name, srcNodeIDType,
+ srcSwitchId, srcNodeConnectorIDType, srcPort,
+ dstNodeIDType, dstSwitchId, dstNodeConnectorIDType, dstPort);
+
+ name = Integer.toString(i + 1);
+ srcSwitchId = Integer.toString(i + 1);
+ srcPort = Integer.toString(i + 1);
+ dstSwitchId = Integer.toString((i + 1) * 10);
+ dstPort = Integer.toString((i + 1) * 10);
+
+ link[i].setName(name);
+ link[i].setSrcSwitchId(srcSwitchId);
+ link[i].setSrcPort(srcPort);
+ link[i].setDstSwitchId(dstSwitchId);
+ link[i].setDstPort(dstPort);
+
+ Assert.assertTrue(link[i].isValid() == false);
+
+ link[i].setSrcNodeIDType("OF");
+ link[i].setSrcNodeConnectorIDType("OF");
+
+ Assert.assertTrue(link[i].isValid() == false);
+
+ link[i].setDstNodeIDType("OF");
+ link[i].setDstNodeConnectorIDType("OF");
+
+ Assert.assertTrue(link[i].isValid() == true);
+
+ reverseLink[i] = new TopologyUserLinkConfig(name, dstNodeIDType,
+ dstSwitchId, dstNodeConnectorIDType, dstPort,
+ srcNodeIDType, srcSwitchId, srcNodeConnectorIDType, srcPort);
+
+ topoManagerImpl.addUserLink(link[i]);
+ }
+ ConcurrentMap<String, TopologyUserLinkConfig> userLinks = topoManagerImpl
+ .getUserLinks();
+ TopologyUserLinkConfig resultLink;
+
+ for (i = 0; i < 5; i++) {
+ resultLink = userLinks.get(((Integer) (i + 1)).toString());
+
+ Assert.assertTrue(resultLink.getName().equals(
+ reverseLink[i].getName()));
+ Assert.assertTrue(resultLink.getDstSwitchId().equals(
+ reverseLink[i].getSrcSwitchId()));
+ Assert.assertTrue(resultLink.getDstPort().equals(
+ reverseLink[i].getSrcPort()));
+ Assert.assertTrue(resultLink.getSrcSwitchId().equals(
+ reverseLink[i].getDstSwitchId()));
+ Assert.assertTrue(resultLink.getSrcPort().equals(
+ reverseLink[i].getDstPort()));
+ }
+ }
+
+ @Test
+ public void testHostLinkMethods() throws ConstructionException,
+ UnknownHostException {
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ topoManagerImpl.nonClusterObjectCreate();
+ int hostCounter = 0;
+
+ State state;
+ Bandwidth bw;
+ Latency l;
+ Set<Property> props = new HashSet<Property>();
+ state = new State(State.EDGE_UP);
+ bw = new Bandwidth(Bandwidth.BW100Gbps);
+ l = new Latency(Latency.LATENCY100ns);
+ props.add(state);
+ props.add(bw);
+ props.add(l);
+
+ EthernetAddress ea;
+ InetAddress ip;
+ Host[] h = new Host[5];
+ NodeConnector[] nc = new NodeConnector[5];
+
+ /*
+ * Adding host, nodeConnector to hostsDB for the i = 0,1,2,3. No host
+ * added for i = 4
+ */
+ for (int i = 0; i < 5; i++) {
+ if (hostCounter < 4) {
+ ea = new EthernetAddress(new byte[] { (byte) 0x0, (byte) 0x0,
+ (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) i });
+ String stringIP = new StringBuilder().append(i + 1).append(".")
+ .append(i + 10).append(".").append(i + 20).append(".")
+ .append(i + 30).toString();
+ ip = InetAddress.getByName(stringIP);
+ h[hostCounter] = new Host(ea, ip);
+ } else {
+ h[hostCounter] = null;
+ }
+ hostCounter++;
+ nc[i] = NodeConnectorCreator.createOFNodeConnector((short) (i + 1),
+ NodeCreator.createOFNode((long) (i + 1)));
+ topoManagerImpl
+ .updateHostLink(nc[i], h[i], UpdateType.ADDED, props);
+ }
+
+ for (int i = 0; i < 5; i++) {
+ Host host = topoManagerImpl.getHostAttachedToNodeConnector(nc[i]);
+ if (i == 4)
+ Assert.assertTrue(host == null);
+ else
+ Assert.assertTrue(host.equals(h[i]));
+ }
+
+ Set<NodeConnector> ncSet = topoManagerImpl.getNodeConnectorWithHost();
+ for (int i = 0; i < 5; i++) {
+ Assert.assertTrue(ncSet.remove(nc[i]));
+ }
+ Assert.assertTrue(ncSet.isEmpty());
+ }
+
+ @Test
+ public void testGetNodesWithNodeConnectorHost()
+ throws ConstructionException, UnknownHostException {
+ TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ topoManagerImpl.nonClusterObjectCreate();
+ int hostCounter = 0;
+
+ State state;
+ Bandwidth bw;
+ Latency l;
+ Set<Property> props = new HashSet<Property>();
+ state = new State(State.EDGE_UP);
+ bw = new Bandwidth(Bandwidth.BW100Gbps);
+ l = new Latency(Latency.LATENCY100ns);
+ props.add(state);
+ props.add(bw);
+ props.add(l);
+
+ EthernetAddress ea;
+ InetAddress ip;
+ Host[] h = new Host[5];
+ NodeConnector[] nc = new NodeConnector[5];
+
+ /*
+ * Adding host, nodeconnector, properties of edge to hostsDB for the
+ * first three nodes only
+ */
+ for (int i = 1; i < 6; i++) {
+ if (i < 4) {
+ ea = new EthernetAddress(new byte[] { (byte) 0x0, (byte) 0x0,
+ (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) i });
+ String stringIP = new StringBuilder().append(i).append(".")
+ .append(i + 10).append(".").append(i + 20).append(".")
+ .append(i + 30).toString();
+ ip = InetAddress.getByName(stringIP);
+ h[hostCounter] = new Host(ea, ip);
+ } else {
+ h[hostCounter] = null;
+ }
+ hostCounter++;
+ nc[i - 1] = NodeConnectorCreator.createOFNodeConnector((short) i,
+ NodeCreator.createOFNode((long) i));
+ topoManagerImpl.updateHostLink(nc[i - 1], h[i - 1],
+ UpdateType.ADDED, props);
+ }
+
+ /* Get the nodes which have host connected to its nodeConnector */
+ Map<Node, Set<NodeConnector>> nodeNCmap = topoManagerImpl
+ .getNodesWithNodeConnectorHost();
+ for (int i = 1; i < 6; i++) {
+ Node node = nc[i - 1].getNode();
+ Set<NodeConnector> ncSet = nodeNCmap.get(nc[i - 1].getNode());
+
+ Assert.assertTrue(ncSet == nodeNCmap.remove(node));
+ }
+
+ Assert.assertTrue(nodeNCmap.isEmpty());
+ }
+}
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.controller.forwarding.staticrouting.IForwardingStaticRouting;
import org.opendaylight.controller.forwarding.staticrouting.StaticRouteConfig;
import org.opendaylight.controller.sal.authorization.UserLevel;
+import org.opendaylight.controller.sal.core.Config;
import org.opendaylight.controller.sal.core.Name;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
HexEncode.bytesToHexString(device.getDataLayerAddress()));
StringBuffer sb1 = new StringBuffer();
Set<NodeConnector> nodeConnectorSet = device.getNodeConnectors();
- String nodeConnectorName;
- String nodeConnectorNumberToStr;
if (nodeConnectorSet != null && nodeConnectorSet.size() > 0) {
Map<Short, String> portList = new HashMap<Short, String>();
for (NodeConnector nodeConnector : nodeConnectorSet) {
- nodeConnectorNumberToStr = nodeConnector.getID().toString();
+ String nodeConnectorNumberToStr = nodeConnector.getID().toString();
Name ncName = ((Name) switchManager.getNodeConnectorProp(
nodeConnector, Name.NamePropName));
- nodeConnectorName = (ncName != null) ? ncName.getValue()
+ Config portStatus = ((Config) switchManager
+ .getNodeConnectorProp(nodeConnector,
+ Config.ConfigPropName));
+
+ String nodeConnectorName = (ncName != null) ? ncName.getValue()
: "";
+ nodeConnectorName += " ("+nodeConnector.getID()+")";
+ if (portStatus.getValue() == Config.ADMIN_UP) {
+ nodeConnectorName = "<span style='color:green;'>"+nodeConnectorName+"</span>";
+ } else if (portStatus.getValue() == Config.ADMIN_DOWN) {
+ nodeConnectorName = "<span style='color:red;'>"+nodeConnectorName+"</span>";
+ }
+
portList.put(Short.parseShort(nodeConnectorNumberToStr),
nodeConnectorName);
}
- Map<Short, String> sortedPortList = new TreeMap<Short, String>(
- portList);
+
+ Map<Short, String> sortedPortList = new TreeMap<Short, String>(portList);
+
for (Entry<Short, String> e : sortedPortList.entrySet()) {
- sb1.append(e.getValue() + "(" + e.getKey() + ")");
+ sb1.append(e.getValue());
sb1.append("<br>");
}
}
columnNames.add("Tier");
columnNames.add("Mac Address");
columnNames.add("Ports");
+ columnNames.add("Port Status");
result.setColumnNames(columnNames);
return result;
package org.opendaylight.controller.devices.web;
public class StatusJsonBean {
- private boolean status;
- private String message;
- public boolean isStatus() {
- return status;
- }
- public void setStatus(boolean status) {
- this.status = status;
- }
- public String getMessage() {
- return message;
- }
- public void setMessage(String message) {
- this.message = message;
- }
+ private boolean status;
+ private String message;
+
+ public boolean isStatus() {
+ return status;
+ }
+
+ public void setStatus(boolean status) {
+ this.status = status;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public void setMessage(String message) {
+ this.message = message;
+ }
}
},
staticRouteConfig : {
id : 'staticRouteConfig',
- name : 'Static route Configuration'
+ name : 'Static Route Configuration'
},
subnetGatewayConfig : {
id : 'subnetGatewayConfig',
form: {
nodeId: "one_f_switchmanager_nodesLearnt_id_modal_form_nodeid",
nodeName : "one_f_switchmanager_nodesLearnt_id_modal_form_nodename",
+ portStatus : "one_f_switchmanager_nodesLearnt_id_modal_form_portstatus",
tier: "one_f_switchmanager_nodesLearnt_id_modal_form_tier",
operationMode: "one_f_switchmanager_nodesLearnt_id_modal_form_opmode"
}
$dashlet.append($table);
});
},
-
ajax : {
main : function(url, callback) {
$.getJSON(url, function(data) {
initialize: {
updateNode: function(evt) {
var nodeId = decodeURIComponent(evt.target.id);
- var h3 = "Update node information";
+ var h3 = "Update Node Information";
var footer = one.f.switchmanager.nodesLearnt.modal.footer.updateNode();
var $modal = one.lib.modal.spawn(one.f.switchmanager.nodesLearnt.id.modal.modal, h3, "", footer);
entry.push(value["tierName"]);
entry.push(value["mac"]);
entry.push(value["ports"]);
+ entry.push(value["portStatus"]);
tr.entry = entry;
result.push(tr);
});
var body = one.f.switchmanager.staticRouteConfig.data.staticRouteConfig(content);
// first column contains checkbox. no need for header
content.columnNames.splice(0,0," ");
- var $table = one.f.switchmanager.createTable(content.columnNames, body);
+ var tableHeaders = ['', 'Name', 'Static Route', 'Next Hop Address'];
+ var $table = one.f.switchmanager.createTable(tableHeaders, body);
$dashlet.append($table);
});
},
// activate first tab on each dashlet
$('.dash .nav').each(function(index, value) {
$($(value).find('li')[0]).find('a').click();
-});
\ No newline at end of file
+});
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
-
/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
import org.opendaylight.controller.sal.authorization.UserLevel;
-/**
- *
- *
- */
public interface IDaylightWeb {
+ /**
+ * Returns the name of the bundle. In the GUI, this name will be displayed
+ * on the tab.
+ *
+ * @return Name assigned to the bundle.
+ */
public String getWebName();
+ /**
+ * Returns the Id assigned to the web bundle.
+ *
+ * @return Id assigned to the web bundle.
+ */
public String getWebId();
+ /**
+ * Returns the position where the bundle tab will be placed in the GUI.
+ *
+ * @return Position number for the bundle tab.
+ */
public short getWebOrder();
-
+
+ /**
+ * This method checks if the user is authorized to access the bundle.
+ *
+ * @param userLevel
+ * user role level in the controller space.
+ *
+ * @return true, if user is authorized to access the bundle, else false.
+ */
public boolean isAuthorized(UserLevel userLevel);
}
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.core.Property;
+import org.opendaylight.controller.sal.core.Node.NodeIDType;
import org.opendaylight.controller.sal.packet.address.EthernetAddress;
import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.controller.switchmanager.ISwitchManager;
for (Map.Entry<Node, Set<Edge>> e : nodeEdges.entrySet()) {
Node n = e.getKey();
+
+ // skip production node
+ if (nodeIgnore(n)) {
+ continue;
+ }
+
String description = switchManager.getNodeDescription(n);
NodeBean node = createNodeBean(description, n);
List<Map<String, Object>> adjacencies = new LinkedList<Map<String, Object>>();
Set<Edge> links = e.getValue();
for (Edge link : links) {
+ if (edgeIgnore(link)) {
+ continue;
+ }
for (Property p : properties.get(link)) {
if (p instanceof Bandwidth) {
bandwidth = (Bandwidth) p;
}
}
+ /**
+ * Check if this node shouldn't appear in the visual topology
+ *
+ * @param node
+ * @return
+ */
+ private boolean nodeIgnore(Node node) {
+ String nodeType = node.getType();
+
+ // add other node types to ignore later
+ if (nodeType.equals(NodeIDType.PRODUCTION)) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Check if this edge shouldn't appear in the visual topology
+ *
+ * @param edge
+ * @return
+ */
+ private boolean edgeIgnore(Edge edge) {
+ NodeConnector headNodeConnector = edge.getHeadNodeConnector();
+ Node headNode = headNodeConnector.getNode();
+ if (nodeIgnore(headNode)) {
+ return true;
+ }
+
+ NodeConnector tailNodeConnector = edge.getTailNodeConnector();
+ Node tailNode = tailNodeConnector.getNode();
+ if (nodeIgnore(tailNode)) {
+ return true;
+ }
+
+ return false;
+ }
+
protected NodeBean createNodeBean(String description, Node node) {
String name = (description == null ||
description.trim().isEmpty() ||
if (nodes == null) return;
for (Switch sw : nodes) {
Node n = sw.getNode();
+
+ // skip production node
+ if (nodeIgnore(n)) {
+ continue;
+ }
String description = switchManager.getNodeDescription(n);
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.4.0-SNAPSHOT</version>
+ <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>