}
}
+ public void _showDropStats(CommandInterpreter ci) {
+ if(sessionInitiated) {
+ ci.println("RPC Test Statistics: " + this.rpcProvider.getStats().toString());
+ ci.println("FRM Test Statistics: " + this.provider.getStats().toString());
+ } else {
+ ci.println("Session not initiated, try again in a few seconds");
+ }
+ }
+
+ public void _clearDropStats(CommandInterpreter ci) {
+ if(sessionInitiated) {
+ ci.print("Clearing drop statistics... ");
+ this.rpcProvider.clearStats();
+ this.provider.clearStats();
+ ci.println("Done.");
+
+ } else {
+ ci.println("Session not initiated, try again in a few seconds");
+ }
+ }
+
@Override
public String getHelp() {
String helpString = "----------------- dropAllPackets--------------\n"
private final DropTestProvider _manager;
+ private int _sent;
+ private int _rcvd;
+
+ public DropTestStats getStats(){
+ return new DropTestStats(this._sent, this._rcvd);
+ }
+
+ public void clearStats(){
+ this._sent = 0;
+ this._rcvd = 0;
+ }
+
public DropTestProvider getManager() {
return this._manager;
}
}
public void onPacketReceived(final PacketReceived notification) {
- LOG.debug("onPacketReceived - Entering - " + notification);
+ // LOG.debug("onPacketReceived - Entering - " + notification);
- // Get the Ingress nodeConnectorRef
+ synchronized(this) {
+ this._rcvd++;
+ }
+
+ // Get the Ingress nodeConnectorRef
final NodeConnectorRef ncr = notification.getIngress();
// Get the instance identifier for the nodeConnectorRef
final NodeKey nodeKey = InstanceIdentifier.<Node, NodeKey>keyOf(nodeInstanceId);
final byte[] rawPacket = notification.getPayload();
- LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} payload {}",
- nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(rawPacket));
+ // LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} payload {}",
+ // nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(rawPacket));
final byte[] srcMac = Arrays.copyOfRange(rawPacket, 6, 12);
- LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} srcMac {}",
- nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(srcMac));
+ //LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} srcMac {}",
+ // nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(srcMac));
final MatchBuilder match = new MatchBuilder();
final EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
final Flow flow = fb.build();
final DataModificationTransaction transaction = this._manager.getDataService().beginTransaction();
- LOG.debug("onPacketReceived - About to write flow - " + flow);
+ // LOG.debug("onPacketReceived - About to write flow - " + flow);
transaction.putConfigurationData(flowInstanceId, flow);
transaction.commit();
- LOG.debug("onPacketReceived - About to write flow commited");
+ // LOG.debug("onPacketReceived - About to write flow commited");
+ synchronized(this) {
+ this._sent++;
+ }
+
}
}
private Registration<NotificationListener> listenerRegistration;
private final DropTestCommiter commiter = new DropTestCommiter(this);
+ public DropTestStats getStats() {
+ return this.commiter.getStats();
+ }
+
+ public void clearStats() {
+ this.commiter.clearStats();
+ }
+
public DataProviderService getDataService() {
return this._dataService;
}
this.listenerRegistration = this.getNotificationService().registerNotificationListener(this.commiter);
LOG.debug("DropTestProvider Started.");
}
+
+ public DropTestStats getStats() {
+ if(this.commiter != null) {
+ return this.commiter.getStats();
+ } else {
+ return new DropTestStats("Not initialized yet.");
+ }
+ }
+
+ public void clearStats() {
+ if(this.commiter != null) {
+ this.commiter.clearStats();
+ }
+ }
public void close() {
try {
*/
package org.opendaylight.openflowplugin.droptest;
-import org.apache.commons.codec.binary.Hex;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropAction;
private final DropTestRpcProvider _manager;
private final SalFlowService _flowService;
+
+ private int _sent;
+ private int _rcvd;
+ private int _excs;
+
+ public DropTestStats getStats(){
+ return new DropTestStats(this._sent, this._rcvd, this._excs);
+ }
+
+ public void clearStats(){
+ this._sent = 0;
+ this._rcvd = 0;
+ this._excs = 0;
+ }
public DropTestRpcProvider getManager() {
return this._manager;
this._flowService = flowService;
}
- public void onPacketReceived(final PacketReceived notification) {
- LOG.debug("onPacketReceived - Entering - " + notification);
-
- // Get the Ingress nodeConnectorRef
- final NodeConnectorRef ncr = notification.getIngress();
-
- // Get the instance identifier for the nodeConnectorRef
- final InstanceIdentifier<NodeConnector> ncri = (InstanceIdentifier<NodeConnector>) ncr.getValue();
- final NodeConnectorKey ncKey = InstanceIdentifier.<NodeConnector, NodeConnectorKey>keyOf(ncri);
-
- // Get the instanceID for the Node in the tree above us
- final InstanceIdentifier<Node> nodeInstanceId = ncri.<Node>firstIdentifierOf(Node.class);
- final NodeKey nodeKey = InstanceIdentifier.<Node, NodeKey>keyOf(nodeInstanceId);
- final byte[] rawPacket = notification.getPayload();
-
- LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} payload {}",
- nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(rawPacket));
-
- final byte[] srcMac = Arrays.copyOfRange(rawPacket, 6, 12);
-
- LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} srcMac {}",
- nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(srcMac));
-
- final MatchBuilder match = new MatchBuilder();
- final EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
- final EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
-
- //TODO: use HEX, use binary form
- //Hex.decodeHex("000000000001".toCharArray());
-
- ethSourceBuilder.setAddress(new MacAddress(DropTestUtils.macToString(srcMac)));
- ethernetMatch.setEthernetSource(ethSourceBuilder.build());
- match.setEthernetMatch(ethernetMatch.build());
- final DropActionBuilder dab = new DropActionBuilder();
- final DropAction dropAction = dab.build();
- final ActionBuilder ab = new ActionBuilder();
- ab.setAction(new DropActionCaseBuilder().setDropAction(dropAction).build());
-
- // Add our drop action to a list
- final ArrayList<Action> actionList = new ArrayList<Action>();
- actionList.add(ab.build());
-
- // Create an Apply Action
- final ApplyActionsBuilder aab = new ApplyActionsBuilder();
- aab.setAction(actionList);
-
- // Wrap our Apply Action in an Instruction
- final InstructionBuilder ib = new InstructionBuilder();
- ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
-
- // Put our Instruction in a list of Instructions
- final InstructionsBuilder isb = new InstructionsBuilder();;
- final ArrayList<Instruction> instructions = new ArrayList<Instruction>();
- instructions.add(ib.build());
- isb.setInstruction(instructions);
-
- // Finally build our flow
- final AddFlowInputBuilder fb = new AddFlowInputBuilder();
- fb.setMatch(match.build());
- fb.setInstructions(isb.build());
- //fb.setId(new FlowId(Long.toString(fb.hashCode)));
-
- // Construct the flow instance id
- final InstanceIdentifier<Node> flowInstanceId = InstanceIdentifier
- .builder(Nodes.class) // File under nodes
- .child(Node.class, nodeKey).toInstance(); // A particular node indentified by nodeKey
- fb.setNode(new NodeRef(flowInstanceId));
-
- fb.setPriority(4);
- fb.setBufferId(0L);
- final BigInteger value = new BigInteger("10", 10);
- fb.setCookie(new FlowCookie(value));
- fb.setCookieMask(new FlowCookie(value));
- fb.setTableId(Short.valueOf(((short) 0)));
- fb.setHardTimeout(300);
- fb.setIdleTimeout(240);
- fb.setFlags(new FlowModFlags(false, false, false, false, false));
-
- // Add flow
- this.getFlowService().addFlow(fb.build());
+ @Override
+ public void onPacketReceived(final PacketReceived notification) {
+ // LOG.debug("onPacketReceived - Entering - " + notification);
+
+ synchronized(this) {
+ this._rcvd++;
+ }
+
+ try {
+ // Get the Ingress nodeConnectorRef
+ final NodeConnectorRef ncr = notification.getIngress();
+
+ // Get the instance identifier for the nodeConnectorRef
+ final InstanceIdentifier<NodeConnector> ncri = (InstanceIdentifier<NodeConnector>) ncr.getValue();
+ final NodeConnectorKey ncKey = InstanceIdentifier.<NodeConnector, NodeConnectorKey>keyOf(ncri);
+
+ // Get the instanceID for the Node in the tree above us
+ final InstanceIdentifier<Node> nodeInstanceId = ncri.<Node>firstIdentifierOf(Node.class);
+ final NodeKey nodeKey = InstanceIdentifier.<Node, NodeKey>keyOf(nodeInstanceId);
+ final byte[] rawPacket = notification.getPayload();
+
+ // LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} payload {}",
+ // nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(rawPacket));
+
+ final byte[] srcMac = Arrays.copyOfRange(rawPacket, 6, 12);
+
+ //LOG.debug("onPacketReceived - received Packet on Node {} and NodeConnector {} srcMac {}",
+ // nodeKey.getId(), ncKey.getId(), Hex.encodeHexString(srcMac));
+
+
+ final MatchBuilder match = new MatchBuilder();
+ final EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
+ final EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
+
+ //TODO: use HEX, use binary form
+ //Hex.decodeHex("000000000001".toCharArray());
+
+ ethSourceBuilder.setAddress(new MacAddress(DropTestUtils.macToString(srcMac)));
+ ethernetMatch.setEthernetSource(ethSourceBuilder.build());
+ match.setEthernetMatch(ethernetMatch.build());
+ final DropActionBuilder dab = new DropActionBuilder();
+ final DropAction dropAction = dab.build();
+ final ActionBuilder ab = new ActionBuilder();
+ ab.setAction(new DropActionCaseBuilder().setDropAction(dropAction).build());
+
+ // Add our drop action to a list
+ final ArrayList<Action> actionList = new ArrayList<Action>();
+ actionList.add(ab.build());
+
+ // Create an Apply Action
+ final ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ // Wrap our Apply Action in an Instruction
+ final InstructionBuilder ib = new InstructionBuilder();
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ final InstructionsBuilder isb = new InstructionsBuilder();;
+ final ArrayList<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+
+ // Finally build our flow
+ final AddFlowInputBuilder fb = new AddFlowInputBuilder();
+ fb.setMatch(match.build());
+ fb.setInstructions(isb.build());
+ //fb.setId(new FlowId(Long.toString(fb.hashCode)));
+
+ // Construct the flow instance id
+ final InstanceIdentifier<Node> flowInstanceId = InstanceIdentifier
+ .builder(Nodes.class) // File under nodes
+ .child(Node.class, nodeKey).toInstance(); // A particular node identified by nodeKey
+ fb.setNode(new NodeRef(flowInstanceId));
+
+ fb.setPriority(4);
+ fb.setBufferId(0L);
+ final BigInteger value = new BigInteger("10", 10);
+ fb.setCookie(new FlowCookie(value));
+ fb.setCookieMask(new FlowCookie(value));
+ fb.setTableId(Short.valueOf(((short) 0)));
+ fb.setHardTimeout(300);
+ fb.setIdleTimeout(240);
+ fb.setFlags(new FlowModFlags(false, false, false, false, false));
+
+ // Add flow
+ this.getFlowService().addFlow(fb.build());
+
+ synchronized (this) {
+ this._sent++;
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ LOG.error("dropTestRpc exception: {}", e.toString());
+ synchronized (this) {
+ this._excs++;
+ }
+ }
}
}
--- /dev/null
+package org.opendaylight.openflowplugin.droptest;
+
+public class DropTestStats {
+ private final int _rcvd;
+ private final int _sent;
+ private final int _excs;
+ private final String _message;
+
+ public DropTestStats(int sent, int rcvd) {
+ this._sent = sent;
+ this._rcvd = rcvd;
+ this._excs = 0;
+ this._message = null;
+ }
+
+ public DropTestStats(int sent, int rcvd, int excs) {
+ this._sent = sent;
+ this._rcvd = rcvd;
+ this._excs = excs;
+ this._message = null;
+ }
+
+ public DropTestStats(String message) {
+ this._sent = -1;
+ this._rcvd = -1;
+ this._excs = -1;
+ this._message = message;
+ }
+
+ public int getSent() { return this._sent; }
+ public int getRcvd() { return this._rcvd; }
+ public String getMessage() { return this._message; };
+
+ @Override
+ public String toString() {
+ StringBuilder result = new StringBuilder();
+ if (this._message == null) {
+ result.append("Rcvd: " + this._rcvd);
+ result.append(", Sent: " + this._sent);
+ result.append("; Exceptions: " + this._excs);
+ } else {
+ result.append(this._message);
+ }
+
+ return result.toString();
+ }
+
+}
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesInputBuilder;
// first Hello sending
sendHelloMessage(highestVersion, getNextXid());
lastProposedVersion = highestVersion;
- LOG.debug("ret - firstHello+wait");
+ LOG.trace("ret - firstHello+wait");
return;
}
// versionBitmap missing at least on one side -> STEP-BY-STEP NEGOTIATION applying
handleStepByStepVersionNegotiation(remoteVersion);
}
- } catch (Throwable ex) {
+ } catch (Exception ex) {
errorHandler.handleException(ex, null);
connectionAdapter.disconnect();
- LOG.debug("ret - "+ex.getMessage());
+ LOG.trace("ret - shake fail: {}", ex.getMessage());
}
}
/**
* @param remoteVersion
- * @throws Throwable
+ * @throws Exception
*/
- private void handleStepByStepVersionNegotiation(Short remoteVersion) throws Throwable {
+ private void handleStepByStepVersionNegotiation(Short remoteVersion) throws Exception {
LOG.debug("remoteVersion:{} lastProposedVersion:{}, highestVersion:{}",
remoteVersion, lastProposedVersion, highestVersion);
if (remoteVersion == lastProposedVersion) {
postHandshake(lastProposedVersion, getNextXid());
- LOG.debug("ret - OK - switch answered with lastProposedVersion");
+ LOG.trace("ret - OK - switch answered with lastProposedVersion");
} else {
checkNegotiationStalling(remoteVersion);
if (remoteVersion > (lastProposedVersion == null ? highestVersion : lastProposedVersion)) {
// wait for next version
- LOG.debug("ret - wait");
+ LOG.trace("ret - wait");
} else {
//propose lower version
handleLowerVersionProposal(remoteVersion);
/**
* @param remoteVersion
- * @throws Throwable
+ * @throws Exception
*/
- private void handleLowerVersionProposal(Short remoteVersion) throws Throwable {
+ private void handleLowerVersionProposal(Short remoteVersion) throws Exception {
Short proposedVersion;
// find the version from header version field
proposedVersion = proposeNextVersion(remoteVersion);
sendHelloMessage(proposedVersion, getNextXid());
if (proposedVersion != remoteVersion) {
- LOG.debug("ret - sent+wait");
+ LOG.trace("ret - sent+wait");
} else {
- LOG.debug("ret - sent+OK");
+ LOG.trace("ret - sent+OK");
postHandshake(proposedVersion, getNextXid());
}
}
/**
* @param elements
- * @throws Throwable
+ * @throws Exception
*/
- private void handleVersionBitmapNegotiation(List<Elements> elements) throws Throwable {
+ private void handleVersionBitmapNegotiation(List<Elements> elements) throws Exception {
Short proposedVersion;
proposedVersion = proposeCommonBitmapVersion(elements);
if (lastProposedVersion == null) {
sendHelloMessage(proposedVersion, getNextXid());
}
postHandshake(proposedVersion, getNextXid());
- LOG.debug("ret - OK - versionBitmap");
+ LOG.trace("ret - OK - versionBitmap");
}
/**
* send hello reply without versionBitmap
* @param helloVersion
* @param helloXid
- * @throws Throwable
+ * @throws Exception
*/
- private void sendHelloMessage(Short helloVersion, Long helloXid) throws Throwable {
+ private void sendHelloMessage(Short helloVersion, Long helloXid) throws Exception {
//Short highestVersion = ConnectionConductor.versionOrder.get(0);
//final Long helloXid = 21L;
HelloInput helloInput = MessageFactory.createHelloInput(helloVersion, helloXid, versionOrder);
RpcResult<Void> helloResult = connectionAdapter.hello(helloInput).get(maxTimeout, maxTimeoutUnit);
RpcUtil.smokeRpc(helloResult);
LOG.debug("FIRST HELLO sent.");
- } catch (Throwable e) {
+ } catch (Exception e) {
LOG.debug("FIRST HELLO sending failed.");
throw e;
}
* after handshake set features, register to session
* @param proposedVersion
* @param xId
- * @throws Throwable
+ * @throws Exception
*/
- protected void postHandshake(Short proposedVersion, Long xid) throws Throwable {
+ protected void postHandshake(Short proposedVersion, Long xid) throws Exception {
// set version
long maxTimeout = 3000;
version = proposedVersion;
- LOG.debug("version set: " + proposedVersion);
+ LOG.debug("version set: {}", proposedVersion);
// request features
GetFeaturesInputBuilder featuresBuilder = new GetFeaturesInputBuilder();
featuresBuilder.setVersion(version).setXid(xid);
version, featureOutput.getDatapathId(), featureOutput.getAuxiliaryId());
handshakeListener.onHandshakeSuccessfull(featureOutput, proposedVersion);
- } catch (Throwable e) {
- //handshake failed
- LOG.error("issuing disconnect during handshake, reason: "+e.getMessage());
+ } catch (TimeoutException e) {
+ // handshake failed
+ LOG.warn("issuing disconnect during handshake, reason: future expired", e);
+ connectionAdapter.disconnect();
+ throw e;
+ } catch (Exception e) {
+ // handshake failed
+ LOG.warn("issuing disconnect during handshake, reason - RPC: {}", e.getMessage(), e);
connectionAdapter.disconnect();
throw e;
}
/**
* @param result
- * @throws Throwable
+ * @throws Exception
*/
- public static void smokeRpc(RpcResult<?> result) throws Throwable {
+ public static void smokeRpc(RpcResult<?> result) throws Exception {
if (!result.isSuccessful()) {
Throwable firstCause = null;
StringBuffer sb = new StringBuffer();
Code Review / openflowplugin.git / commitdiff