private ConcurrentMap<FlowEntry, FlowEntry> inactiveFlows;
private IContainer container;
- private Set<IForwardingRulesManagerAware> frmAware;
+ private Set<IForwardingRulesManagerAware> frmAware =
+ Collections.synchronizedSet(new HashSet<IForwardingRulesManagerAware>());
private PortGroupProvider portGroupProvider;
private IFlowProgrammerService programmer;
private IClusterContainerServices clusterContainerService = null;
*
*/
void init() {
- frmAware = Collections.synchronizedSet(new HashSet<IForwardingRulesManagerAware>());
frmFileName = GlobalConstants.STARTUPHOME.toString() + "frm_staticflows_" + this.getContainerName() + ".conf";
portGroupFileName = GlobalConstants.STARTUPHOME.toString() + "portgroup_" + this.getContainerName() + ".conf";
*
*/
void destroy() {
+ frmAware.clear();
}
/**
*/
package org.opendaylight.controller.subnets.northbound;
-import java.util.ArrayList;
import java.util.HashSet;
-import java.util.List;
import java.util.Set;
import javax.ws.rs.Consumes;
throw new ResourceNotFoundException(RestMessages.NOCONTAINER.toString());
}
- SubnetConfig cfgObject = new SubnetConfig(subnetName, subnet, new ArrayList<String>(0));
+ SubnetConfig cfgObject = new SubnetConfig(subnetName, subnet, new HashSet<String>(0));
Status status = switchManager.addSubnet(cfgObject);
if (status.isSuccess()) {
return Response.status(Response.Status.CREATED).build();
} else {
Status st;
boolean successful = true;
- List<String> ports = subnetConf.getNodePorts();
+ Set<String> ports = subnetConf.getNodePorts();
if (action.equals("add")) {
// add new ports
private ConcurrentMap<Long, Boolean> switchSupportsVendorExtStats;
// Per port sampled (every portStatsPeriod) transmit rate
private Map<Long, Map<Short, TxRates>> txRates;
- private Set<IOFStatisticsListener> statisticsListeners;
+ private Set<IOFStatisticsListener> statisticsListeners = new CopyOnWriteArraySet<IOFStatisticsListener>();
/**
* The object containing the latest factoredSamples tx rate samples for a
switchPortStatsUpdated = new LinkedBlockingQueue<Long>(INITIAL_SIZE);
switchSupportsVendorExtStats = new ConcurrentHashMap<Long, Boolean>(INITIAL_SIZE);
txRates = new HashMap<Long, Map<Short, TxRates>>(INITIAL_SIZE);
- statisticsListeners = new CopyOnWriteArraySet<IOFStatisticsListener>();
configStatsPollIntervals();
*
*/
void destroy() {
+ statisticsListeners.clear();
}
/**
private static final Logger logger = LoggerFactory
.getLogger(ReadService.class);
private IReadServiceFilter filter;
- private Set<IPluginOutReadService> pluginOutReadServices;
+ private Set<IPluginOutReadService> pluginOutReadServices = new CopyOnWriteArraySet<IPluginOutReadService>();
private String containerName;
private IPluginOutConnectionService connectionOutService;
@SuppressWarnings("unchecked")
void init(Component c) {
Dictionary<Object, Object> props = c.getServiceProperties();
- containerName = (props != null) ? (String) props.get("containerName")
- : null;
- pluginOutReadServices = new CopyOnWriteArraySet<IPluginOutReadService>();
+ containerName = (props != null) ? (String) props.get("containerName") : null;
}
/**
*
*/
void destroy() {
+ pluginOutReadServices.clear();
}
/**
private ConcurrentMap<String, Set<Node>> containerToNode;
private ConcurrentMap<String, Set<NodeTable>> containerToNt;
private ConcurrentMap<String, Set<ContainerFlow>> containerFlows;
- private ConcurrentMap<String, IReadFilterInternalListener> readFilterInternalListeners;
+ private ConcurrentMap<String, IReadFilterInternalListener> readFilterInternalListeners =
+ new ConcurrentHashMap<String, IReadFilterInternalListener>();
public void setController(IController core) {
this.controller = core;
containerToNt = new ConcurrentHashMap<String, Set<NodeTable>>();
containerToNode = new ConcurrentHashMap<String, Set<Node>>();
containerFlows = new ConcurrentHashMap<String, Set<ContainerFlow>>();
- readFilterInternalListeners = new ConcurrentHashMap<String, IReadFilterInternalListener>();
}
/**
*
*/
void destroy() {
+ readFilterInternalListeners.clear();
}
/**
public class ReadService implements IReadService, CommandProvider, IPluginOutReadService {
protected static final Logger logger = LoggerFactory.getLogger(ReadService.class);
- private ConcurrentHashMap<String, IPluginInReadService> pluginReader;
- private Set<IReadServiceListener> readerListeners;
+ private ConcurrentHashMap<String, IPluginInReadService> pluginReader =
+ new ConcurrentHashMap<String, IPluginInReadService>();
+ private Set<IReadServiceListener> readerListeners =
+ new CopyOnWriteArraySet<IReadServiceListener>();
/**
* Function called by the dependency manager when all the required
*
*/
void init() {
- pluginReader = new ConcurrentHashMap<String, IPluginInReadService>();
- readerListeners = new CopyOnWriteArraySet<IReadServiceListener>();
}
/**
// In case of plugin disactivating make sure we clear the
// dependencies
this.pluginReader.clear();
+ this.readerListeners.clear();
}
/**
// Retrieve current statistics so we don't have to wait for next refresh
ISwitchManager switchManager = (ISwitchManager) ServiceHelper.getInstance(
ISwitchManager.class, container.getName(), this);
- if (reader != null && switchManager != null) {
+ if ((reader != null) && (switchManager != null)) {
Set<Node> nodeSet = switchManager.getNodes();
for (Node node : nodeSet) {
- flowStatistics.put(node, reader.readAllFlows(node));
- descriptionStatistics.put(node, reader.readDescription(node));
- tableStatistics.put(node, reader.readNodeTable(node));
- nodeConnectorStatistics.put(node, reader.readNodeConnectors(node));
+ List<FlowOnNode> flows = reader.readAllFlows(node);
+ if (flows != null) {
+ flowStatistics.put(node, flows);
+ }
+ NodeDescription descr = reader.readDescription(node);
+ if (descr != null) {
+ descriptionStatistics.put(node, descr);
+ }
+ List<NodeTableStatistics> tableStats = reader.readNodeTable(node);
+ if (tableStats != null) {
+ tableStatistics.put(node, tableStats);
+ }
+ List<NodeConnectorStatistics> ncStats = reader.readNodeConnectors(node);
+ if (ncStats != null) {
+ nodeConnectorStatistics.put(node, ncStats);
+ }
}
} else {
* @param sp Set of NodeConnectors to add to the subnet
*/
public void addNodeConnectors(Set<NodeConnector> sp) {
- if (sp == null) {
- return;
- }
-
- for (NodeConnector p : sp) {
- this.nodeConnectors.add(p);
+ if (sp != null) {
+ this.nodeConnectors.addAll(sp);
}
}
private String subnet; // A.B.C.D/MM Where A.B.C.D is the Default
// Gateway IP (L3) or ARP Querier IP (L2
@XmlElement
- private List<String> nodePorts; // datapath ID/port list:
+ private Set<String> nodePorts; // datapath ID/port list:
// xx:xx:xx:xx:xx:xx:xx:xx/a,b,c-m,r-t,y
public SubnetConfig() {
}
- public SubnetConfig(String desc, String sub, List<String> sp) {
+ public SubnetConfig(String desc, String sub, Set<String> sp) {
name = desc;
subnet = sub;
nodePorts = sp;
public SubnetConfig(SubnetConfig subnetConfig) {
name = subnetConfig.name;
subnet = subnetConfig.subnet;
- nodePorts = new ArrayList<String>(subnetConfig.nodePorts);
+ nodePorts = new HashSet<String>(subnetConfig.nodePorts);
}
public String getName() {
return name;
}
- public List<String> getNodePorts() {
+ public Set<String> getNodePorts() {
return nodePorts;
}
private static final String SAVE = "Save";
private String subnetFileName, spanFileName, switchConfigFileName;
private final List<NodeConnector> spanNodeConnectors = new CopyOnWriteArrayList<NodeConnector>();
- // set of Subnets keyed by the InetAddress
+ // Collection of Subnets keyed by the InetAddress
private ConcurrentMap<InetAddress, Subnet> subnets;
private ConcurrentMap<String, SubnetConfig> subnetsConfigList;
private ConcurrentMap<SpanConfig, SpanConfig> spanConfigList;
Set<NodeConnector> sp = conf.getSubnetNodeConnectors();
subnet.addNodeConnectors(sp);
}
- boolean result = false;
+ boolean putNewSubnet = false;
if(subnetCurr == null) {
if(subnets.putIfAbsent(conf.getIPnum(), subnet) == null) {
- result = true;
+ putNewSubnet = true;
}
} else {
- result = subnets.replace(conf.getIPnum(), subnetCurr, subnet);
+ putNewSubnet = subnets.replace(conf.getIPnum(), subnetCurr, subnet);
}
- if(!result) {
+ if(!putNewSubnet) {
String msg = "Cluster conflict: Conflict while adding the subnet " + conf.getIPnum();
return new Status(StatusCode.CONFLICT, msg);
}
- } else { // This is the deletion of the whole subnet
+
+ // Subnet removal case
+ } else {
subnets.remove(conf.getIPnum());
}
return new Status(StatusCode.SUCCESS);
return new Status(StatusCode.SUCCESS);
}
- private Status addRemoveSubnet(SubnetConfig conf, boolean add) {
+ private Status addRemoveSubnet(SubnetConfig conf, boolean isAdding) {
// Valid config check
if (!conf.isValidConfig()) {
String msg = "Invalid Subnet configuration";
return new Status(StatusCode.BADREQUEST, msg);
}
- if (add) {
+ if (isAdding) {
// Presence check
if (subnetsConfigList.containsKey(conf.getName())) {
return new Status(StatusCode.CONFLICT,
- "Same subnet config already exists");
+ "Subnet with the specified name already configured.");
}
- // Semantyc check
+ // Semantic check
Status rc = semanticCheck(conf);
if (!rc.isSuccess()) {
return rc;
}
// Update Database
- Status rc = updateDatabase(conf, add);
+ Status rc = updateDatabase(conf, isAdding);
if (rc.isSuccess()) {
// Update Configuration
- rc = updateConfig(conf, add);
+ rc = updateConfig(conf, isAdding);
if(!rc.isSuccess()) {
- updateDatabase(conf, (!add));
+ updateDatabase(conf, (!isAdding));
}
}
Subnet sub = subCurr.clone();
Set<NodeConnector> sp = confCurr.getNodeConnectors(switchPorts);
sub.addNodeConnectors(sp);
- boolean subnetsReplace = subnets.replace(confCurr.getIPnum(), subCurr, sub);
- if (!subnetsReplace) {
+ boolean subnetsReplaced = subnets.replace(confCurr.getIPnum(), subCurr, sub);
+ if (!subnetsReplaced) {
String msg = "Cluster conflict: Conflict while adding ports to the subnet " + name;
return new Status(StatusCode.CONFLICT, msg);
}
// Update Configuration
SubnetConfig conf = confCurr.clone();
conf.addNodeConnectors(switchPorts);
- boolean result = subnetsConfigList.replace(name, confCurr, conf);
- if (!result) {
+ boolean configReplaced = subnetsConfigList.replace(name, confCurr, conf);
+ if (!configReplaced) {
// TODO: recovery using Transactionality
String msg = "Cluster conflict: Conflict while adding ports to the subnet " + name;
return new Status(StatusCode.CONFLICT, msg);
package org.opendaylight.controller.switchmanager.internal;
-import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
SwitchManager switchmgr = new SwitchManager();
switchmgr.startUp();
- ArrayList<String> portList = new ArrayList<String>();
+ Set<String> portList = new HashSet<String>();
portList.add("1/1");
portList.add("1/2");
portList.add("1/3");
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
ISwitchManager switchManager = (ISwitchManager) ServiceHelper
.getInstance(ISwitchManager.class, containerName, this);
SubnetConfig cfgObject = new SubnetConfig(gatewayName,
- gatewayIPAddress, new ArrayList<String>());
+ gatewayIPAddress, new HashSet<String>());
Status result = switchManager.addSubnet(cfgObject);
if (result.isSuccess()) {
resultBean.setStatus(true);
Code Review / controller.git / commitdiff