public void shutDown() {
}
- @SuppressWarnings("deprecation")
private void allocateCaches() {
if (this.clusterContainerService == null) {
this.nonClusterObjectCreate();
EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
clusterContainerService.createCache("switchmanager.subnets",
EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
- clusterContainerService.createCache(
- "switchmanager.configSaveEvent",
- EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
clusterContainerService.createCache("switchmanager.nodeProps",
EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
clusterContainerService.createCache(
}
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCaches() {
if (this.clusterContainerService == null) {
log.info("un-initialized clusterContainerService, can't create cache");
private Status updateDatabase(SubnetConfig conf, boolean add) {
if (add) {
- Subnet subnetCurr = subnets.get(conf.getIPnum());
+ Subnet subnetCurr = subnets.get(conf.getIPAddress());
Subnet subnet;
if (subnetCurr == null) {
subnet = new Subnet(conf);
// In case of API3 call we may receive the ports along with the
// subnet creation
if (!conf.isGlobal()) {
- Set<NodeConnector> sp = conf.getSubnetNodeConnectors();
- subnet.addNodeConnectors(sp);
+ subnet.addNodeConnectors(conf.getNodeConnectors());
}
boolean putNewSubnet = false;
if(subnetCurr == null) {
- if(subnets.putIfAbsent(conf.getIPnum(), subnet) == null) {
+ if(subnets.putIfAbsent(conf.getIPAddress(), subnet) == null) {
putNewSubnet = true;
}
} else {
- putNewSubnet = subnets.replace(conf.getIPnum(), subnetCurr, subnet);
+ putNewSubnet = subnets.replace(conf.getIPAddress(), subnetCurr, subnet);
}
if(!putNewSubnet) {
- String msg = "Cluster conflict: Conflict while adding the subnet " + conf.getIPnum();
+ String msg = "Cluster conflict: Conflict while adding the subnet " + conf.getIPAddress();
return new Status(StatusCode.CONFLICT, msg);
}
// Subnet removal case
} else {
- subnets.remove(conf.getIPnum());
+ subnets.remove(conf.getIPAddress());
}
return new Status(StatusCode.SUCCESS);
}
}
private Status addRemoveSubnet(SubnetConfig conf, boolean isAdding) {
- // Valid config check
- if (!conf.isValidConfig()) {
- String msg = "Invalid Subnet configuration";
- log.warn(msg);
- return new Status(StatusCode.BADREQUEST, msg);
+ // Valid configuration check
+ Status status = conf.validate();
+ if (!status.isSuccess()) {
+ log.warn(status.getDescription());
+ return status;
}
if (isAdding) {
"Subnet with the specified name already configured.");
}
// Semantic check
- Status rc = semanticCheck(conf);
- if (!rc.isSuccess()) {
- return rc;
+ status = semanticCheck(conf);
+ if (!status.isSuccess()) {
+ return status;
}
}
// Update Database
- Status rc = updateDatabase(conf, isAdding);
+ status = updateDatabase(conf, isAdding);
- if (rc.isSuccess()) {
+ if (status.isSuccess()) {
// Update Configuration
- rc = updateConfig(conf, isAdding);
- if(!rc.isSuccess()) {
+ status = updateConfig(conf, isAdding);
+ if(!status.isSuccess()) {
updateDatabase(conf, (!isAdding));
}
}
- return rc;
+ return status;
}
/**
}
@Override
- public Status addPortsToSubnet(String name, String switchPorts) {
+ public Status modifySubnet(SubnetConfig conf) {
+ // Sanity check
+ if (conf == null) {
+ return new Status(StatusCode.BADREQUEST, "Invalid Subnet configuration: null");
+ }
+
+ // Valid configuration check
+ Status status = conf.validate();
+ if (!status.isSuccess()) {
+ log.warn(status.getDescription());
+ return status;
+ }
+
+ // If a subnet configuration with this name does not exist, consider this is a creation
+ SubnetConfig target = subnetsConfigList.get(conf.getName());
+ if (target == null) {
+ return this.addSubnet(conf);
+ }
+
+ // No change
+ if (target.equals(conf)) {
+ return new Status(StatusCode.SUCCESS);
+ }
+
+ // Check not allowed modifications
+ if (!target.getSubnet().equals(conf.getSubnet())) {
+ return new Status(StatusCode.BADREQUEST, "IP address change is not allowed");
+ }
+
+ // Derive the set of node connectors that are being removed
+ Set<NodeConnector> toRemove = target.getNodeConnectors();
+ toRemove.removeAll(conf.getNodeConnectors());
+ List<String> nodeConnectorStrings = null;
+ if (!toRemove.isEmpty()) {
+ nodeConnectorStrings = new ArrayList<String>();
+ for (NodeConnector nc : toRemove) {
+ nodeConnectorStrings.add(nc.toString());
+ }
+ status = this.removePortsFromSubnet(conf.getName(), nodeConnectorStrings);
+ if (!status.isSuccess()) {
+ return status;
+ }
+ }
+
+ // Derive the set of node connectors that are being added
+ Set<NodeConnector> toAdd = conf.getNodeConnectors();
+ toAdd.removeAll(target.getNodeConnectors());
+ if (!toAdd.isEmpty()) {
+ List<String> nodeConnectorStringRemoved = nodeConnectorStrings;
+ nodeConnectorStrings = new ArrayList<String>();
+ for (NodeConnector nc : toAdd) {
+ nodeConnectorStrings.add(nc.toString());
+ }
+ status = this.addPortsToSubnet(conf.getName(), nodeConnectorStrings);
+ if (!status.isSuccess()) {
+ // If any port was removed, add it back as a best recovery effort
+ if (!toRemove.isEmpty()) {
+ this.addPortsToSubnet(conf.getName(), nodeConnectorStringRemoved);
+ }
+ return status;
+ }
+ }
+
+ // Update Configuration
+ subnetsConfigList.put(conf.getName(), conf);
+
+ return new Status(StatusCode.SUCCESS);
+ }
+
+ @Override
+ public Status addPortsToSubnet(String name, List<String> switchPorts) {
+ if (name == null) {
+ return new Status(StatusCode.BADREQUEST, "Null subnet name");
+ }
SubnetConfig confCurr = subnetsConfigList.get(name);
if (confCurr == null) {
return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
}
- if (!confCurr.isValidSwitchPort(switchPorts)) {
- return new Status(StatusCode.BADREQUEST, "Invalid switchports");
+
+ if (switchPorts == null || switchPorts.isEmpty()) {
+ return new Status(StatusCode.BADREQUEST, "Null or empty port set");
}
- Subnet subCurr = subnets.get(confCurr.getIPnum());
+ Subnet subCurr = subnets.get(confCurr.getIPAddress());
if (subCurr == null) {
- log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPnum());
+ log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPAddress());
return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
}
// Update Database
Subnet sub = subCurr.clone();
- Set<NodeConnector> sp = confCurr.getNodeConnectors(switchPorts);
+ Set<NodeConnector> sp = NodeConnector.fromString(switchPorts);
sub.addNodeConnectors(sp);
- boolean subnetsReplaced = subnets.replace(confCurr.getIPnum(), subCurr, sub);
+ boolean subnetsReplaced = subnets.replace(confCurr.getIPAddress(), subCurr, sub);
if (!subnetsReplaced) {
String msg = "Cluster conflict: Conflict while adding ports to the subnet " + name;
return new Status(StatusCode.CONFLICT, msg);
}
@Override
- public Status removePortsFromSubnet(String name, String switchPorts) {
+ public Status removePortsFromSubnet(String name, List<String> switchPorts) {
+ if (name == null) {
+ return new Status(StatusCode.BADREQUEST, "Null subnet name");
+ }
SubnetConfig confCurr = subnetsConfigList.get(name);
if (confCurr == null) {
return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
}
- Subnet subCurr = subnets.get(confCurr.getIPnum());
+ if (switchPorts == null || switchPorts.isEmpty()) {
+ return new Status(StatusCode.BADREQUEST, "Null or empty port set");
+ }
+
+ Subnet subCurr = subnets.get(confCurr.getIPAddress());
if (subCurr == null) {
- log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPnum());
+ log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPAddress());
return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
}
+ // Validation check
+ Status status = SubnetConfig.validatePorts(switchPorts);
+ if (!status.isSuccess()) {
+ return status;
+ }
// Update Database
Subnet sub = subCurr.clone();
- Set<NodeConnector> sp = confCurr.getNodeConnectors(switchPorts);
+ Set<NodeConnector> sp = NodeConnector.fromString(switchPorts);
sub.deleteNodeConnectors(sp);
- boolean subnetsReplace = subnets.replace(confCurr.getIPnum(), subCurr, sub);
+ boolean subnetsReplace = subnets.replace(confCurr.getIPAddress(), subCurr, sub);
if (!subnetsReplace) {
String msg = "Cluster conflict: Conflict while removing ports from the subnet " + name;
return new Status(StatusCode.CONFLICT, msg);
}
}
+ @SuppressWarnings("deprecation")
@Override
public void updateSwitchConfig(SwitchConfig cfgObject) {
// update default container only
switchConfig = new SwitchConfig(nodeId, updateProperties);
} else {
// check if description is configured or was published by any other node
- for (Node n : nodeProps.keySet()) {
+ for (Map.Entry<Node, Map<String, Property>> entry : nodeProps.entrySet()) {
+ Node n = entry.getKey();
Description desc = (Description) getNodeProp(n, Description.propertyName);
NodeDescription nDesc = (this.statisticsManager == null) ? null : this.statisticsManager
.getNodeDescription(n);
return new Status(StatusCode.SUCCESS);
}
Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
- for (String prop : prevNodeProperties.keySet()) {
+ for (Map.Entry<String, Property> entry : prevNodeProperties.entrySet()) {
+ String prop = entry.getKey();
if (!updateProperties.containsKey(prop)) {
if (prop.equals(Description.propertyName)) {
if (!advertisedDesc.isEmpty()) {
propMap.put(Description.propertyName, desc);
}
continue;
+ } else if (prop.equals(ForwardingMode.name)) {
+ Property defaultMode = new ForwardingMode(ForwardingMode.REACTIVE_FORWARDING);
+ propMap.put(ForwardingMode.name, defaultMode);
+ continue;
}
propMap.remove(prop);
}
Map<String, Property> propMapCurr = nodeProps.get(node);
if ((propMapCurr != null) && (nodeProperties != null) && (!nodeProperties.isEmpty())) {
Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
- for (String prop : nodeProperties.keySet()) {
+ for (Map.Entry<String, Property> entry : nodeProperties.entrySet()) {
+ String prop = entry.getKey();
if (prop.equals(Description.propertyName)) {
Map<Node, Map<String, Property>> nodeProp = this.inventoryService.getNodeProps();
if (nodeProp.get(node) != null) {
}
}
- // copy node properties from config
boolean proactiveForwarding = false;
+ // copy node properties from config
if (nodeConfigList != null) {
String nodeId = node.toString();
SwitchConfig conf = nodeConfigList.get(nodeId);
}
}
+ if (!propMap.containsKey(ForwardingMode.name)) {
+ Property defaultMode = new ForwardingMode(ForwardingMode.REACTIVE_FORWARDING);
+ propMap.put(ForwardingMode.name, defaultMode);
+ }
boolean result = false;
if (propMapCurr == null) {
if (nodeProps.putIfAbsent(node, propMap) == null) {
return;
}
nodeProps.remove(node);
+ nodeConnectorNames.remove(node);
+ Set<NodeConnector> removeNodeConnectorSet = new HashSet<NodeConnector>();
+ for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
+ NodeConnector nodeConnector = entry.getKey();
+ if (nodeConnector.getNode().equals(node)) {
+ removeNodeConnectorSet.add(nodeConnector);
+ }
+ }
+ for (NodeConnector nc : removeNodeConnectorSet) {
+ nodeConnectorProps.remove(nc);
+ }
// check if span ports need to be cleaned up
removeSpanPorts(node);
public void updateNodeConnector(NodeConnector nodeConnector,
UpdateType type, Set<Property> props) {
Map<String, Property> propMap = new HashMap<String, Property>();
+ boolean update = true;
log.debug("updateNodeConnector: {} type {} props {} for container {}",
new Object[] { nodeConnector, type, props, containerName });
switch (type) {
case ADDED:
- case CHANGED:
if (props != null) {
for (Property prop : props) {
addNodeConnectorProp(nodeConnector, prop);
addSpanPort(nodeConnector);
break;
+ case CHANGED:
+ if (!nodeConnectorProps.containsKey(nodeConnector) || (props == null)) {
+ update = false;
+ } else {
+ for (Property prop : props) {
+ addNodeConnectorProp(nodeConnector, prop);
+ propMap.put(prop.getName(), prop);
+ }
+ }
+ break;
case REMOVED:
+ if (!nodeConnectorProps.containsKey(nodeConnector)) {
+ update = false;
+ }
removeNodeConnectorAllProps(nodeConnector);
// clean up span config
removeSpanPort(nodeConnector);
break;
default:
+ update = false;
break;
}
- notifyNodeConnector(nodeConnector, type, propMap);
+ if (update) {
+ notifyNodeConnector(nodeConnector, type, propMap);
+ }
}
@Override
public Set<Node> getNodes() {
return (nodeProps != null) ? new HashSet<Node>(nodeProps.keySet())
- : null;
+ : new HashSet<Node>();
}
/*
}
Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
- for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
+ for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
+ NodeConnector nodeConnector = entry.getKey();
if (!nodeConnector.getNode().equals(node)) {
continue;
}
}
Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
- for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
+ for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
+ NodeConnector nodeConnector = entry.getKey();
if (!nodeConnector.getNode().equals(node)) {
continue;
}
}
Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
- for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
+ for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
+ NodeConnector nodeConnector = entry.getKey();
if (!nodeConnector.getNode().equals(node)
|| isSpecial(nodeConnector)) {
continue;
Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
if (mapCurr != null) {
- for (String s : mapCurr.keySet()) {
+ for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
+ String s = entry.getKey();
try {
- map.put(s, new NodeConnector(mapCurr.get(s)));
+ map.put(s, new NodeConnector(entry.getValue()));
} catch (ConstructionException e) {
- e.printStackTrace();
+ log.error("An error occured",e);
}
}
}
Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
if (mapCurr != null) {
Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
- for (String s : mapCurr.keySet()) {
+ for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
+ String s = entry.getKey();
try {
- map.put(s, new NodeConnector(mapCurr.get(s)));
+ map.put(s, new NodeConnector(entry.getValue()));
} catch (ConstructionException e) {
- e.printStackTrace();
+ log.error("An error occured",e);
}
}
map.remove(name.getValue());
Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
if (mapCurr != null) {
Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
- for (String s : mapCurr.keySet()) {
+ for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
+ String s = entry.getKey();
try {
- map.put(s, new NodeConnector(mapCurr.get(s)));
+ map.put(s, new NodeConnector(entry.getValue()));
} catch (ConstructionException e) {
- e.printStackTrace();
+ log.error("An error occured",e);
}
}
map.remove(name.getValue());
service.notifyNode(node, type, propMap);
}
- for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
+ for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
+ NodeConnector nodeConnector = entry.getKey();
propMap = nodeConnectorProps.get(nodeConnector);
service.notifyNodeConnector(nodeConnector, type, propMap);
}
public String getHelp() {
StringBuffer help = new StringBuffer();
help.append("---Switch Manager---\n");
- help.append("\t pns - Print connected nodes\n");
- help.append("\t pncs <node id> - Print node connectors for a given node\n");
help.append("\t pencs <node id> - Print enabled node connectors for a given node\n");
help.append("\t pdm <node id> - Print switch ports in device map\n");
help.append("\t snt <node id> <tier> - Set node tier number\n");
return help.toString();
}
- public void _pns(CommandInterpreter ci) {
- ci.println(" Node Type MAC Name Tier");
- if (nodeProps == null) {
- return;
- }
- Set<Node> nodeSet = nodeProps.keySet();
- if (nodeSet == null) {
- return;
- }
- List<String> nodeArray = new ArrayList<String>();
- for (Node node : nodeSet) {
- nodeArray.add(node.toString());
- }
- Collections.sort(nodeArray);
- for (String str: nodeArray) {
- Node node = Node.fromString(str);
- Description desc = ((Description) getNodeProp(node,
- Description.propertyName));
- Tier tier = ((Tier) getNodeProp(node, Tier.TierPropName));
- String nodeName = (desc == null) ? "" : desc.getValue();
- MacAddress mac = (MacAddress) getNodeProp(node,
- MacAddress.name);
- String macAddr = (mac == null) ? "" : HexEncode
- .bytesToHexStringFormat(mac.getMacAddress());
- int tierNum = (tier == null) ? 0 : tier.getValue();
- ci.println(node + " " + node.getType() + " " + macAddr
- + " " + nodeName + " " + tierNum);
- }
- ci.println("Total number of Nodes: " + nodeSet.size());
- }
-
public void _pencs(CommandInterpreter ci) {
String st = ci.nextArgument();
if (st == null) {
ci.println("Total number of NodeConnectors: " + nodeConnectorSet.size());
}
- public void _pncs(CommandInterpreter ci) {
- String st = ci.nextArgument();
- if (st == null) {
- ci.println("Please enter node id");
- return;
- }
-
- Node node = Node.fromString(st);
- if (node == null) {
- ci.println("Please enter node id");
- return;
- }
-
- ci.println(" NodeConnector BandWidth(Gbps) Admin State");
- Set<NodeConnector> nodeConnectorSet = getNodeConnectors(node);
- if (nodeConnectorSet == null) {
- return;
- }
- for (NodeConnector nodeConnector : nodeConnectorSet) {
- if (nodeConnector == null) {
- continue;
- }
- Map<String, Property> propMap = getNodeConnectorProps(nodeConnector);
- Bandwidth bw = (Bandwidth) propMap.get(Bandwidth.BandwidthPropName);
- Config config = (Config) propMap.get(Config.ConfigPropName);
- State state = (State) propMap.get(State.StatePropName);
- String out = nodeConnector + " ";
- out += (bw != null) ? bw.getValue() / Math.pow(10, 9) : " ";
- out += " ";
- out += (config != null) ? config.getValue() : " ";
- out += " ";
- out += (state != null) ? state.getValue() : " ";
- ci.println(out);
- }
- ci.println("Total number of NodeConnectors: " + nodeConnectorSet.size());
- }
-
public void _pdm(CommandInterpreter ci) {
String st = ci.nextArgument();
if (st == null) {
Switch sw = getSwitchByNode(node);
ci.println(" NodeConnector Name");
- if (sw == null) {
- return;
- }
+
Set<NodeConnector> nodeConnectorSet = sw.getNodeConnectors();
String nodeConnectorName;
if (nodeConnectorSet != null && nodeConnectorSet.size() > 0) {
return null;
}
+ @SuppressWarnings("deprecation")
@Override
public String getNodeDescription(Node node) {
// Check first if user configured a name