// replication is done in the SAL implementation toward
// the different APPS
this.pluginOutDataPacketServices.put(containerName, s);
- logger.debug("New outService for container:" + containerName);
+ logger.debug("New outService for container: {}", containerName);
}
}
}
if (this.pluginOutDataPacketServices != null) {
this.pluginOutDataPacketServices.remove(containerName);
- logger.debug("Removed outService for container:" + containerName);
+ logger.debug("Removed outService for container: {}", containerName);
}
}
if (sw == null || msg == null
|| this.pluginOutDataPacketServices == null) {
// Something fishy, we cannot do anything
+ logger.debug("sw: {} and/or msg: {} and/or pluginOutDataPacketServices: {} is null!",
+ new Object[]{sw, msg, this.pluginOutDataPacketServices});
return;
}
if (msg instanceof OFPacketIn) {
.get(GlobalConstants.DEFAULT.toString());
if (defaultOutService != null) {
defaultOutService.receiveDataPacket(dataPacket);
- logger.trace("Dispatched to apps a frame of size: "
- + ofPacket.getPacketData().length
- + " on container: "
- + GlobalConstants.DEFAULT.toString());
+ logger.trace("Dispatched to apps a frame of size: {} on container: {}",
+ ofPacket.getPacketData().length, GlobalConstants.DEFAULT.toString());
}
// Now check the mapping between nodeConnector and
// Container and later on optinally filter based on
if (s != null) {
// TODO add filtering on a per-flowSpec base
s.receiveDataPacket(dataPacket);
- logger.trace("Dispatched to apps a frame of size: "
- + ofPacket.getPacketData().length
- + " on container: " + container);
+ logger.trace("Dispatched to apps a frame of size: {} on container: {}",
+ ofPacket.getPacketData().length, GlobalConstants.DEFAULT.toString());
}
}
public void transmitDataPacket(RawPacket outPkt) {
// Sanity check area
if (outPkt == null) {
+ logger.debug("outPkt is null!");
return;
}
NodeConnector outPort = outPkt.getOutgoingNodeConnector();
if (outPort == null) {
+ logger.debug("outPort is null! outPkt: {}", outPkt);
return;
}
if (!outPort.getType().equals(
NodeConnector.NodeConnectorIDType.OPENFLOW)) {
// The output Port is not of type OpenFlow
+ logger.debug("outPort is not OF Type! outPort: {}", outPort);
return;
}
if (sw == null) {
// If we cannot get the controller descriptor we cannot even
// send out the frame
+ logger.debug("swID: {} - sw is null!", swID);
return;
}
po.setPacketData(data);
sw.asyncSend(po);
- logger.trace("Transmitted a frame of size:" + data.length);
+ logger.trace("Transmitted a frame of size: {}", data.length);
}
public void addNode(Node node, Set<Property> props) {
- if (node == null)
+ if (node == null) {
+ logger.debug("node is null!");
return;
+ }
long sid = (Long) node.getID();
ISwitch sw = controller.getSwitches().get(sid);
- if (sw != null) {
- this.swID2ISwitch.put(sw.getId(), sw);
+ if (sw == null) {
+ logger.debug("sid: {} - sw is null!", sid);
+ return;
}
+ this.swID2ISwitch.put(sw.getId(), sw);
}
public void removeNode(Node node) {
- if (node == null)
+ if (node == null) {
+ logger.debug("node is null!");
return;
+ }
long sid = (Long) node.getID();
ISwitch sw = controller.getSwitches().get(sid);
- if (sw != null) {
- this.swID2ISwitch.remove(sw.getId());
+ if (sw == null) {
+ logger.debug("sid: {} - sw is null!", sid);
+ return;
}
+ this.swID2ISwitch.remove(sw.getId());
}
@Override
if (fSpecs == null) {
fSpecs = new CopyOnWriteArrayList<ContainerFlow>();
}
- boolean updateMap = false;
switch (t) {
case ADDED:
if (!fSpecs.contains(previousFlow)) {
case CHANGED:
break;
}
- if (updateMap) {
- if (fSpecs.isEmpty()) {
- this.container2FlowSpecs.remove(containerName);
- } else {
- this.container2FlowSpecs.put(containerName, fSpecs);
- }
- }
}
@Override
this.routingAware = new HashSet<IListenRoutingUpdates>();
}
if (this.routingAware != null) {
- log.debug("Adding routingAware listener: " + i);
+ log.debug("Adding routingAware listener: {}", i);
this.routingAware.add(i);
}
}
: avlDstThruPut;
if (avlThruPut <= 0) {
- log
- .trace(
- "Edge {}: Available Throughput {} is Zero/Negative",
- e, avlThruPut);
+ log.debug("Edge {}: Available Throughput {} <= 0!",
+ e, avlThruPut);
return (double) -1;
}
return (double) (Bandwidth.BW1Pbps / avlThruPut);
@Override
public synchronized Path getMaxThroughputRoute(Node src, Node dst) {
if (mtp == null) {
- log
- .error("Max Throughput Path Calculation has not been Initialized!");
+ log.error("Max Throughput Path Calculation Uninitialized!");
return 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;
if (topo.containsVertex(src.getNode())
&& topo.inDegree(src.getNode()) == 0
&& topo.outDegree(src.getNode()) == 0) {
- log.debug("Removing vertex " + src);
+ log.debug("Removing vertex {}", src);
topo.removeVertex(src.getNode());
}
if (topo.containsVertex(dst.getNode())
&& topo.inDegree(dst.getNode()) == 0
&& topo.outDegree(dst.getNode()) == 0) {
- log.debug("Removing vertex " + dst);
+ log.debug("Removing vertex {}", dst);
topo.removeVertex(dst.getNode());
}
}
clearMaxThroughput();
}
} else {
- log.error("Cannot find topology for BW " + bw
- + " this is unexpected!");
+ log.error("Cannot find topology for BW {} this is unexpected!", bw);
}
return edgePresentInGraph;
}
if (props != null)
props.remove(bw);
- log.debug("edgeUpdate: " + e.toString() + " bw: " + bw.getValue());
+ log.debug("edgeUpdate: {} bw: {}", e.toString(), bw.getValue());
Short baseBW = Short.valueOf((short) 0);
boolean add = (type == UpdateType.ADDED) ? true : false;
public void containerCreate(String containerName) {
try {
Object[] imps = getImplementations();
- logger.trace("Creating instance " + containerName);
+ logger.trace("Creating instance {}", containerName);
if (imps != null) {
for (int i = 0; i < imps.length; i++) {
ImmutablePair<String, Object> key = new ImmutablePair<String, Object>(
// Set the implementation so the component can manage
// its lifecycle
if (c.getService() == null) {
- logger
- .trace("Setting implementation to:"
- + imps[i]);
+ logger.trace("Setting implementation to: {}",
+ imps[i]);
c.setImplementation(imps[i]);
}
public void containerDestroy(String containerName) {
try {
Object[] imps = getImplementations();
- logger.trace("Destroying instance " + containerName);
+ logger.trace("Destroying instance {}", containerName);
if (imps != null) {
for (int i = 0; i < imps.length; i++) {
ImmutablePair<String, Object> key = new ImmutablePair<String, Object>(
// Set the implementation so the component
// can manage its lifesycle
if (c.getService() == null) {
- logger.trace("Setting implementation to:"
- + imps[i]);
+ logger.trace("Setting implementation to: {}",
+ imps[i]);
c.setImplementation(imps[i]);
}
try {
Component c = this.dbInstances.get(key);
if (c != null) {
- logger.trace("Remove component on container:"
- + key.getLeft() + " Object:" + key.getRight());
+ logger.trace("Remove component on container: {} Object: {}",
+ key.getLeft(), key.getRight());
this.dm.remove(c);
}
} catch (Exception nex) {
try {
Component c = this.dbGlobalInstances.get(key);
if (c != null) {
- logger.trace("Remove component for Object:" + key);
+ logger.trace("Remove component for Object: {}" , key);
this.dm.remove(c);
}
} catch (Exception nex) {
logger.trace("Received setPluginInDataService request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
}
Object value = props.get("protocolPluginType");
+ "protocolPluginType provided");
} else {
this.pluginInDataService.put(type, s);
- logger.debug("Stored the PluginInDataService for type:" + type);
+ logger.debug("Stored the PluginInDataService for type: {}", type);
}
}
logger.trace("Received unsetPluginInDataService request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
}
Object value = props.get("protocoloPluginType");
+ "protocolPluginType provided");
} else if (this.pluginInDataService.get(type).equals(s)) {
this.pluginInDataService.remove(type);
- logger.debug("Removed the PluginInDataService for type:" + type);
+ logger.debug("Removed the PluginInDataService for type: {}", type);
}
}
logger.trace("Received setListenDataPacket request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
}
String listenerName = null;
if (this.indexDataPacket.contains(l)) {
logger.error("trying to add an existing element");
} else {
- logger.debug("adding listener: " + listenerName);
+ logger.debug("adding listener: {}", listenerName);
CopyOnWriteArrayList<DataPacketListener> serialListeners = new CopyOnWriteArrayList<DataPacketListener>();
serialListeners.add(l);
this.listenDataPacket.add(serialListeners);
if (this.indexDataPacket.contains(l)) {
logger.error("trying to add an existing element");
} else {
- logger.debug("adding listener: " + listenerName);
+ logger.debug("adding listener: {}", listenerName);
// Lets find the set with the dependency in it, if we
// find it lets just add our dependency at the end of
// the list.
logger.trace("Received UNsetListenDataPacket request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
}
String listenerName = null;
if (!this.indexDataPacket.contains(l)) {
logger.error("trying to remove a non-existing element");
} else {
- logger.debug("removing listener: " + listenerName);
+ logger.debug("removing listener: {}", listenerName);
for (List<DataPacketListener> serialListeners : this.listenDataPacket) {
int i = 0;
boolean done = false;
String type = null;
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(),
+ entry.getValue());
}
Object value = props.get("protocolPluginType");
+ "protocolPluginType provided");
} else {
this.pluginFlowProgrammer.put(type, s);
- logger.debug("Stored the pluginFlowProgrammer for type:" + type);
+ logger.debug("Stored the pluginFlowProgrammer for type: {}",type);
}
}
logger.debug("Received unsetpluginFlowProgrammer request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})",entry.getKey(),
+ entry.getValue());
}
Object value = props.get("protocoloPluginType");
+ "protocolPluginType provided");
} else if (this.pluginFlowProgrammer.get(type).equals(s)) {
this.pluginFlowProgrammer.remove(type);
- logger.debug("Removed the pluginFlowProgrammer for type:" + type);
+ logger.debug("Removed the pluginFlowProgrammer for type: {}", type);
}
}
String type = null;
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})", entry.getKey(),
+ entry.getValue());
}
Object value = props.get("protocolPluginType");
+ "protocolPluginType provided");
} else {
this.pluginReader.put(type, s);
- logger.debug("Stored the pluginReader for type:" + type);
+ logger.debug("Stored the pluginReader for type: {}", type);
}
}
logger.debug("Received unsetpluginReader request");
for (Object e : props.entrySet()) {
Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:(" + entry.getKey() + ") value:("
- + entry.getValue() + ")");
+ logger.trace("Prop key:({}) value:({})", entry.getKey(),
+ entry.getValue());
}
Object value = props.get("protocoloPluginType");
+ "protocolPluginType provided");
} else if (this.pluginReader.get(type).equals(s)) {
this.pluginReader.remove(type);
- logger.debug("Removed the pluginReader for type:" + type);
+ logger.debug("Removed the pluginReader for type: {}", type);
}
}
.readFlow(node, flow, true);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readFlow(node, flow, false);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readAllFlow(node, true);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readAllFlow(node, false);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readDescription(node, true);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readDescription(node, false);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readNodeConnector(connector, true);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readNodeConnector(connector, false);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readAllNodeConnector(node, true);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.readAllNodeConnector(node, false);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return null;
}
.getTransmitRate(connector);
}
}
- logger.warn("Plugin unuvailable");
+ logger.warn("Plugin unavailable");
return 0;
}