import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
+import org.opendaylight.controller.switchmanager.ISwitchManager;
import org.opendaylight.controller.topologymanager.ITopologyManager;
import org.opendaylight.controller.topologymanager.ITopologyManagerAware;
import org.opendaylight.controller.topologymanager.ITopologyManagerClusterWideAware;
private static final Logger log = LoggerFactory.getLogger(TopologyManagerImpl.class);
private ITopologyService topoService;
private IClusterContainerServices clusterContainerService;
+ private ISwitchManager switchManager;
// DB of all the Edges with properties which constitute our topology
private ConcurrentMap<Edge, Set<Property>> edgesDB;
// DB of all NodeConnector which are part of ISL Edges, meaning they
}
}
+ void setSwitchManager(ISwitchManager s) {
+ log.debug("Adding ISwitchManager: {}", s);
+ this.switchManager = s;
+ }
+
+ void unsetSwitchManager(ISwitchManager s) {
+ if (this.switchManager == s) {
+ log.debug("Removing ISwitchManager: {}", s);
+ this.switchManager = null;
+ }
+ }
+
/**
* Function called by the dependency manager when all the required
* dependencies are satisfied
}
}
+ private boolean nodeConnectorsExist(Edge e) {
+ NodeConnector head = e.getHeadNodeConnector();
+ NodeConnector tail = e.getTailNodeConnector();
+ return (switchManager.doesNodeConnectorExist(head) &&
+ switchManager.doesNodeConnectorExist(tail));
+ }
+
private TopoEdgeUpdate edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
switch (type) {
case ADDED:
+ // Ensure that both tail and head node connectors exist.
+ if (!nodeConnectorsExist(e)) {
+ log.warn("Ignore edge that contains invalid node connector: {}", e);
+ return null;
+ }
+
// Make sure the props are non-null
if (props == null) {
props = new HashSet<Property>();
Set<Property> p = topoedgeupdateList.get(i).getProperty();
UpdateType type = topoedgeupdateList.get(i).getUpdateType();
TopoEdgeUpdate teu = edgeUpdate(e, type, p);
- teuList.add(teu);
+ if (teu != null) {
+ teuList.add(teu);
+ }
}
- // Now update the listeners
- for (ITopologyManagerAware s : this.topologyManagerAware) {
- try {
- s.edgeUpdate(teuList);
- } catch (Exception exc) {
- log.error("Exception on edge update:", exc);
+ if (!teuList.isEmpty()) {
+ // Now update the listeners
+ for (ITopologyManagerAware s : this.topologyManagerAware) {
+ try {
+ s.edgeUpdate(teuList);
+ } catch (Exception exc) {
+ log.error("Exception on edge update:", exc);
+ }
}
}
-
}
private Edge getReverseLinkTuple(TopologyUserLinkConfig link) {
Edge linkTuple = getLinkTuple(userLink);
if (linkTuple != null) {
if (!isProductionLink(linkTuple)) {
- edgeUpdate(linkTuple, UpdateType.ADDED, new HashSet<Property>());
+ TopoEdgeUpdate teu = edgeUpdate(linkTuple, UpdateType.ADDED,
+ new HashSet<Property>());
+ if (teu == null) {
+ userLinksDB.remove(userLink.getName());
+ return new Status(StatusCode.NOTFOUND,
+ "Link configuration contains invalid node connector: "
+ + userLink);
+ }
}
linkTuple = getReverseLinkTuple(userLink);
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.Node.NodeIDType;
import org.opendaylight.controller.sal.core.NodeConnector;
+import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
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.packet.address.EthernetAddress;
import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
+import org.opendaylight.controller.sal.utils.Status;
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.switchmanager.ISwitchManager;
+import org.opendaylight.controller.switchmanager.SpanConfig;
+import org.opendaylight.controller.switchmanager.Subnet;
+import org.opendaylight.controller.switchmanager.SubnetConfig;
+import org.opendaylight.controller.switchmanager.Switch;
+import org.opendaylight.controller.switchmanager.SwitchConfig;
import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
public class TopologyManagerImplTest {
+ /**
+ * Mockup of switch manager that only maintains existence of node
+ * connector.
+ */
+ private final class TestSwitchManager implements ISwitchManager {
+ private final Set<Node> nodeSet = new HashSet<Node>();
+ private final Set<NodeConnector> nodeConnectorSet =
+ new HashSet<NodeConnector>();
+
+ private void addNodeConnectors(NodeConnector ... connectors) {
+ for (NodeConnector nc: connectors) {
+ if (nc != null) {
+ nodeSet.add(nc.getNode());
+ nodeConnectorSet.add(nc);
+ }
+ }
+ }
+
+ private void addNodeConnectors(TopologyUserLinkConfig ... links) {
+ for (TopologyUserLinkConfig link: links) {
+ NodeConnector src =
+ NodeConnector.fromString(link.getSrcNodeConnector());
+ NodeConnector dst =
+ NodeConnector.fromString(link.getDstNodeConnector());
+ addNodeConnectors(src, dst);
+ }
+ }
+
+ @Override
+ public Status addSubnet(SubnetConfig configObject) {
+ return null;
+ }
+
+ @Override
+ public Status removeSubnet(SubnetConfig configObject) {
+ return null;
+ }
+
+ @Override
+ public Status modifySubnet(SubnetConfig configObject) {
+ return null;
+ }
+
+ @Override
+ public Status removeSubnet(String name) {
+ return null;
+ }
+
+ @Override
+ public List<Switch> getNetworkDevices() {
+ return null;
+ }
+
+ @Override
+ public List<SubnetConfig> getSubnetsConfigList() {
+ return null;
+ }
+
+ @Override
+ public SubnetConfig getSubnetConfig(String subnet) {
+ return null;
+ }
+
+ @Override
+ public Subnet getSubnetByNetworkAddress(InetAddress networkAddress) {
+ return null;
+ }
+
+ @Override
+ public Status saveSwitchConfig() {
+ return null;
+ }
+
+ @Override
+ public Status addSpanConfig(SpanConfig configObject) {
+ return null;
+ }
+
+ @Override
+ public Status removeSpanConfig(SpanConfig cfgObject) {
+ return null;
+ }
+
+ @Override
+ public List<SpanConfig> getSpanConfigList() {
+ return null;
+ }
+
+ @Override
+ public List<NodeConnector> getSpanPorts(Node node) {
+ return null;
+ }
+
+ @Override
+ public void updateSwitchConfig(SwitchConfig cfgObject) {
+ }
+
+ @Override
+ public Status updateNodeConfig(SwitchConfig switchConfig) {
+ return null;
+ }
+
+ @Override
+ public Status removeNodeConfig(String nodeId) {
+ return null;
+ }
+
+ @Override
+ public SwitchConfig getSwitchConfig(String nodeId) {
+ return null;
+ }
+
+ @Override
+ public Status addPortsToSubnet(String name, List<String> nodeConnectors) {
+ return null;
+ }
+
+ @Override
+ public Status removePortsFromSubnet(String name, List<String> nodeConnectors) {
+ return null;
+ }
+
+ @Override
+ public Set<Node> getNodes() {
+ return new HashSet<Node>(nodeSet);
+ }
+
+ @Override
+ public Map<String, Property> getNodeProps(Node node) {
+ return new HashMap<String, Property>();
+ }
+
+ @Override
+ public Property getNodeProp(Node node, String propName) {
+ return null;
+ }
+
+ @Override
+ public void setNodeProp(Node node, Property prop) {
+ }
+
+ @Override
+ public Status removeNodeProp(Node node, String propName) {
+ return null;
+ }
+
+ @Override
+ public Status removeNodeAllProps(Node node) {
+ return null;
+ }
+
+ @Override
+ public Set<NodeConnector> getUpNodeConnectors(Node node) {
+ return getNodeConnectors(node);
+ }
+
+ @Override
+ public Set<NodeConnector> getNodeConnectors(Node node) {
+ Set<NodeConnector> set = new HashSet<NodeConnector>();
+ for (NodeConnector nc: nodeConnectorSet) {
+ if (nc.getNode().equals(node)) {
+ set.add(nc);
+ }
+ }
+
+ return set;
+ }
+
+ @Override
+ public Set<NodeConnector> getPhysicalNodeConnectors(Node node) {
+ return getNodeConnectors(node);
+ }
+
+ @Override
+ public Map<String, Property> getNodeConnectorProps(NodeConnector nodeConnector) {
+ return new HashMap<String, Property>();
+ }
+
+ @Override
+ public Property getNodeConnectorProp(NodeConnector nodeConnector, String propName) {
+ return null;
+ }
+
+ @Override
+ public Status addNodeConnectorProp(NodeConnector nodeConnector, Property prop) {
+ return null;
+ }
+
+ @Override
+ public Status removeNodeConnectorProp(NodeConnector nc, String propName) {
+ return null;
+ }
+
+ @Override
+ public Status removeNodeConnectorAllProps(NodeConnector nodeConnector) {
+ return null;
+ }
+
+ @Override
+ public NodeConnector getNodeConnector(Node node, String nodeConnectorName) {
+ return null;
+ }
+
+ @Override
+ public boolean isSpecial(NodeConnector p) {
+ String type = p.getType();
+ return (type.equals(NodeConnectorIDType.CONTROLLER)
+ || type.equals(NodeConnectorIDType.ALL)
+ || type.equals(NodeConnectorIDType.SWSTACK)
+ || type.equals(NodeConnectorIDType.HWPATH));
+ }
+
+ @Override
+ public Boolean isNodeConnectorEnabled(NodeConnector nodeConnector) {
+ if (doesNodeConnectorExist(nodeConnector)) {
+ return Boolean.TRUE;
+ }
+ return Boolean.FALSE;
+ }
+
+ @Override
+ public boolean doesNodeConnectorExist(NodeConnector nc) {
+ return (nc != null && nodeConnectorSet.contains(nc));
+ }
+
+ @Override
+ public byte[] getControllerMAC() {
+ return new byte[6];
+ }
+
+ @Override
+ public byte[] getNodeMAC(Node node) {
+ return new byte[6];
+ }
+
+ @Override
+ public boolean isHostRefreshEnabled() {
+ return true;
+ }
+
+ @Override
+ public int getHostRetryCount() {
+ return 1;
+ }
+
+ @Override
+ public Property createProperty(String propName, String propValue) {
+ return null;
+ }
+
+ @Override
+ public String getNodeDescription(Node node) {
+ return null;
+ }
+ }
/*
* Sets the node, edges and properties for edges here: Edge <SwitchId :
*
* @throws ConstructionException
*/
- public void setNodeEdges(TopologyManagerImpl topoManagerImpl)
+ public void setNodeEdges(TopologyManagerImpl topoManagerImpl, TestSwitchManager swMgr)
throws ConstructionException {
topoManagerImpl.nonClusterObjectCreate();
NodeConnector tailnc1 = NodeConnectorCreator
.createOFNodeConnector((short) (i + 10),
NodeCreator.createOFNode((long) (i + 10)));
+ swMgr.addNodeConnectors(tailnc1, headnc1);
Edge e1 = new Edge(tailnc1, headnc1);
TopoEdgeUpdate teu1 = new TopoEdgeUpdate(e1, props,
UpdateType.ADDED);
(short) (i + 1), headnc1.getNode());
NodeConnector headnc2 = NodeConnectorCreator.createOFNodeConnector(
(short) (i + 11), tailnc1.getNode());
+ swMgr.addNodeConnectors(tailnc1, headnc2);
Edge e2 = new Edge(tailnc2, headnc2);
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);
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
+ setNodeEdges(topoManagerImpl, swMgr);
Map<Node, Set<Edge>> nodeEdgeMap = topoManagerImpl.getNodeEdges();
for (Iterator<Map.Entry<Node, Set<Edge>>> i = nodeEdgeMap.entrySet()
@Test
public void testGetEdges() throws ConstructionException {
TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
- setNodeEdges(topoManagerImpl);
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
+ setNodeEdges(topoManagerImpl, swMgr);
Map<Edge, Set<Property>> edgeProperty = topoManagerImpl.getEdges();
"OF|10@OF|20", "OF|10@OF|20");
TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
topoManagerImpl.nonClusterObjectCreate();
+ swMgr.addNodeConnectors(link1, link2, link3, link4);
+
Assert.assertTrue(topoManagerImpl.addUserLink(link1).isSuccess());
Assert.assertTrue(topoManagerImpl.addUserLink(link2).getCode() == StatusCode.CONFLICT);
Assert.assertTrue(topoManagerImpl.addUserLink(link3).getCode() == StatusCode.CONFLICT);
.isSuccess());
Assert.assertTrue(topoManagerImpl.getUserLinks().isEmpty());
+ TopologyUserLinkConfig badlink1 =
+ new TopologyUserLinkConfig("bad1", "OF|1@OF|2", "OF|1@OF|3");
+ TopologyUserLinkConfig badlink2 =
+ new TopologyUserLinkConfig("bad2", "OF|10@OF|21", "OF|10@OF|20");
+ Assert.assertEquals(StatusCode.NOTFOUND,
+ topoManagerImpl.addUserLink(badlink1).getCode());
+ Assert.assertEquals(StatusCode.NOTFOUND,
+ topoManagerImpl.addUserLink(badlink2).getCode());
}
@Test
TopologyUserLinkConfig[] link = new TopologyUserLinkConfig[5];
TopologyUserLinkConfig[] reverseLink = new TopologyUserLinkConfig[5];
TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
topoManagerImpl.nonClusterObjectCreate();
String name = "Test";
Assert.assertTrue(link[i].isValid() == true);
reverseLink[i] = new TopologyUserLinkConfig(name, dstNodeConnector, srcNodeConnector);
- topoManagerImpl.addUserLink(link[i]);
+
+ Assert.assertEquals(StatusCode.NOTFOUND,
+ topoManagerImpl.addUserLink(link[i]).getCode());
+ swMgr.addNodeConnectors(link[i]);
+ Assert.assertTrue(topoManagerImpl.addUserLink(link[i]).isSuccess());
}
ConcurrentMap<String, TopologyUserLinkConfig> userLinks = topoManagerImpl
public void testHostLinkMethods() throws ConstructionException,
UnknownHostException {
TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
topoManagerImpl.nonClusterObjectCreate();
int hostCounter = 0;
public void testGetNodesWithNodeConnectorHost()
throws ConstructionException, UnknownHostException {
TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
+ TestSwitchManager swMgr = new TestSwitchManager();
+ topoManagerImpl.setSwitchManager(swMgr);
topoManagerImpl.nonClusterObjectCreate();
int hostCounter = 0;
Code Review / controller.git / commitdiff