import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.DataModification;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.controller.sal.binding.api.NotificationService;
import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Dscp;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlDstActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlSrcActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlTypeActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNextHopActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwDstActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanCfiActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanIdActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanPcpActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.StripVlanActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SwPathActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.controller.action._case.ControllerActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlInBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.cfi.action._case.SetVlanCfiActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.id.action._case.SetVlanIdActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.pcp.action._case.SetVlanPcpActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.strip.vlan.action._case.StripVlanActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.sw.path.action._case.SwPathActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAdded;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemoved;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowUpdated;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeErrorNotification;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeExperimenterErrorNotification;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SwitchFlowRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.protocol.match.fields.PbbBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
public class OpenflowpluginTestCommandProvider implements CommandProvider {
private NodeBuilder testNode;
private final String originalFlowName = "Foo";
private final String updatedFlowName = "Bar";
+ private final FlowEventListener flowEventListener = new FlowEventListener();
+ private final PortEventListener portEventListener = new PortEventListener();
+ private static NotificationService notificationService;
+ private Registration<org.opendaylight.yangtools.yang.binding.NotificationListener> listener1Reg;
+ private Registration<org.opendaylight.yangtools.yang.binding.NotificationListener> listener2Reg;
public OpenflowpluginTestCommandProvider(BundleContext ctx) {
this.ctx = ctx;
public void onSessionInitiated(ProviderContext session) {
pc = session;
+ notificationService = session.getSALService(NotificationService.class);
+ // For switch events
+ listener1Reg = notificationService.registerNotificationListener(flowEventListener);
+ listener2Reg = notificationService.registerNotificationListener(portEventListener);
dataBrokerService = session.getSALService(DataBrokerService.class);
ctx.registerService(CommandProvider.class.getName(), this, null);
- createTestFlow(createTestNode(null), null);
+ createTestFlow(createTestNode(null), null, null);
}
private NodeBuilder createTestNode(String nodeId) {
return builder;
}
+ final class FlowEventListener implements SalFlowListener {
+
+ List<FlowAdded> addedFlows = new ArrayList<>();
+ List<FlowRemoved> removedFlows = new ArrayList<>();
+ List<FlowUpdated> updatedFlows = new ArrayList<>();
+
+ @Override
+ public void onFlowAdded(FlowAdded notification) {
+ LOG.info("flow to be added.........................." + notification.toString());
+ LOG.info("added flow Xid........................." + notification.getTransactionId().getValue());
+ LOG.info("-----------------------------------------------------------------------------------");
+ addedFlows.add(notification);
+ }
+
+ @Override
+ public void onFlowRemoved(FlowRemoved notification) {
+ LOG.info("removed flow.........................." + notification.toString());
+ LOG.info("remove flow Xid........................." + notification.getTransactionId().getValue());
+ LOG.info("-----------------------------------------------------------------------------------");
+ removedFlows.add(notification);
+ };
+
+ @Override
+ public void onFlowUpdated(FlowUpdated notification) {
+ LOG.info("updated flow.........................." + notification.toString());
+ LOG.info("updated flow Xid........................." + notification.getTransactionId().getValue());
+ LOG.info("-----------------------------------------------------------------------------------");
+ updatedFlows.add(notification);
+ }
+
+ @Override
+ public void onNodeErrorNotification(NodeErrorNotification notification) {
+ LOG.info("Error notification flow Xid........................."
+ + notification.getTransactionId().getValue());
+ LOG.info("-----------------------------------------------------------------------------------");
+ }
+
+ @Override
+ public void onNodeExperimenterErrorNotification(NodeExperimenterErrorNotification notification) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onSwitchFlowRemoved(SwitchFlowRemoved notification) {
+ LOG.info("Switch flow removed : Cookies..................." + notification.getCookie().toString());
+ LOG.info("-----------------------------------------------------------------------------------");
+ }
+
+ }
+
+ final class PortEventListener implements OpendaylightInventoryListener {
+
+ List<NodeUpdated> nodeUpdated = new ArrayList<>();
+ List<NodeRemoved> nodeRemoved = new ArrayList<>();
+ List<NodeConnectorUpdated> nodeConnectorUpdated = new ArrayList<>();
+ List<NodeConnectorRemoved> nodeConnectorRemoved = new ArrayList<>();
+
+ @Override
+ public void onNodeConnectorRemoved(NodeConnectorRemoved notification) {
+ LOG.info("NodeConnectorRemoved Notification ...................");
+ LOG.info(notification.getNodeConnectorRef().toString());
+ LOG.info("----------------------------------------------------------------------");
+ nodeConnectorRemoved.add(notification);
+ }
+
+ @Override
+ public void onNodeConnectorUpdated(NodeConnectorUpdated notification) {
+ LOG.info("NodeConnectorUpdated Notification...................");
+ LOG.info(notification.getNodeConnectorRef().toString());
+ LOG.info("----------------------------------------------------------------------");
+ nodeConnectorUpdated.add(notification);
+ }
+
+ @Override
+ public void onNodeRemoved(NodeRemoved notification) {
+ LOG.info("NodeConnectorUpdated Notification ...................");
+ LOG.info(notification.getNodeRef().toString());
+ LOG.info("----------------------------------------------------------------------");
+ nodeRemoved.add(notification);
+ }
+
+ @Override
+ public void onNodeUpdated(NodeUpdated notification) {
+ LOG.info("NodeConnectorUpdated Notification ...................");
+ LOG.info(notification.getNodeRef().toString());
+ LOG.info("----------------------------------------------------------------------");
+ nodeUpdated.add(notification);
+ }
+ }
+
private InstanceIdentifier<Node> nodeBuilderToInstanceId(NodeBuilder node) {
return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
}
- private FlowBuilder createTestFlow(NodeBuilder nodeBuilder, String flowTypeArg) {
+ private FlowBuilder createTestFlow(NodeBuilder nodeBuilder, String flowTypeArg, String tableId) {
FlowBuilder flow = new FlowBuilder();
long id = 123;
case "f31":
id += 31;
flow.setMatch(createMatch1().build());
- flow.setInstructions(createAppyActionInstruction23().build());
+ flow.setInstructions(createAppyActionInstruction23(nodeBuilder.getId()).build());
break;
case "f32":
id += 32;
break;
case "f44":
id += 44;
- flow.setMatch(createInphyportMatch().build());
+ flow.setMatch(createInphyportMatch(nodeBuilder.getId()).build());
flow.setInstructions(createDropInstructions().build());
break;
case "f45":
flow.setMatch(createPbbMatch().build());
flow.setInstructions(createMeterInstructions().build());
break;
+ case "f51":
+ id += 51;
+ flow.setMatch(createVlanMatch().build());
+ flow.setInstructions(createDropInstructions().build());
+ break;
+ case "f52":
+ id += 52;
+ flow.setMatch(createL4TCPMatch().build());
+ flow.setInstructions(createDropInstructions().build());
+ break;
+
+ case "f53":
+ id += 53;
+ flow.setMatch(createL4UDPMatch().build());
+ flow.setInstructions(createDropInstructions().build());
+ break;
+ case "f54":
+ id += 54;
+ flow.setMatch(new MatchBuilder().build());
+ flow.setInstructions(createSentToControllerInstructions().build());
+ break;
+ case "f55":
+ id += 55;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createDropInstructions().build());
+ break;
+ case "f56":
+ id += 56;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("INPORT", 10).build());
+ break;
+ case "f57":
+ id += 57;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("FLOOD", 20).build());
+ break;
+ case "f58":
+ id += 58;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("ALL", 30).build());
+ break;
+ case "f59":
+ id += 59;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("NORMAL", 40).build());
+ break;
+ case "f60":
+ id += 60;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("LOCAL", 50).build());
+ break;
+ case "f61":
+ id += 61;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("TABLE", 60).build());
+ break;
+ case "f62":
+ id += 62;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createOutputInstructions("NONE", 70).build());
+ break;
+ case "f63":
+ id += 63;
+ flow.setMatch(createToSMatch().build());
+ flow.setInstructions(createStripVlanInstructions().build());
+ flow.setBarrier(Boolean.TRUE);
+ break;
+ case "f64":
+ id += 64;
+ flow.setMatch(createMatch1().build());
+ flow.setInstructions(createAppyActionInstruction35().build());
+ break;
+ case "f65":
+ id += 65;
+ flow.setMatch(createMatch1().build());
+ flow.setInstructions(createAppyActionInstruction36().build());
+ break;
+ case "f66":
+ id += 66;
+ flow.setMatch(createMatch1().build());
+ flow.setInstructions(createAppyActionInstruction37().build());
+ break;
+ case "f67":
+ id += 67;
+ flow.setMatch(createMatch1().build());
+ flow.setInstructions(createAppyActionInstruction38().build());
+ break;
+ case "f68":
+ id += 68;
+ flow.setMatch(createL4TCPMatch().build());
+ flow.setInstructions(createAppyActionInstruction39().build());
+ break;
+ case "f69":
+ id += 69;
+ flow.setMatch(createL4UDPMatch().build());
+ flow.setInstructions(createAppyActionInstruction40().build());
+ break;
+ case "f70":
+ id += 70;
+ flow.setMatch(createL4SCTPMatch().build());
+ flow.setInstructions(createAppyActionInstruction41().build());
+ break;
+ case "f71":
+ id += 71;
+ flow.setMatch(createICMPv4Match().build());
+ flow.setInstructions(createAppyActionInstruction42().build());
+ break;
+ case "f72":
+ id += 72;
+ flow.setMatch(createArpMatch().build());
+ flow.setInstructions(createAppyActionInstruction43().build());
+ break;
+ case "f73":
+ id += 73;
+ flow.setMatch(createL3IPv6Match().build());
+ flow.setInstructions(createAppyActionInstruction44().build());
+ break;
+ case "f74":
+ id += 74;
+ flow.setMatch(createICMPv6Match().build());
+ flow.setInstructions(createAppyActionInstruction45().build());
+ break;
+ case "f75":
+ id += 75;
+ flow.setMatch(createMplsMatch().build());
+ flow.setInstructions(createAppyActionInstruction46().build());
+ break;
+ case "f76":
+ id += 76;
+ flow.setMatch(createPbbMatch().build());
+ flow.setInstructions(createAppyActionInstruction47().build());
+ break;
+ case "f77":
+ id += 77;
+ flow.setMatch(createTunnelIDMatch().build());
+ flow.setInstructions(createAppyActionInstruction48().build());
+ break;
+ case "f78":
+ id += 78;
+ flow.setMatch(createMatch33().build());
+ flow.setInstructions(createDropInstructions().build());
+ break;
+ case "f79":
+ id += 79;
+ flow.setMatch(createICMPv6Match1().build());
+ flow.setInstructions(createDecNwTtlInstructions().build());
+ break;
+ case "f80":
+ id += 80;
+ flow.setMatch(createMatch1().build());
+ flow.setInstructions(createAppyActionInstruction88().build());
+ break;
default:
LOG.warn("flow type not understood: {}", flowType);
}
- FlowKey key = new FlowKey(new FlowId(id));
- flow.setBarrier(false);
+ FlowKey key = new FlowKey(new FlowId(Long.toString(id)));
+ if (null == flow.isBarrier()) {
+ flow.setBarrier(Boolean.FALSE);
+ }
// flow.setBufferId(new Long(12));
BigInteger value = new BigInteger("10", 10);
+ BigInteger outputPort = new BigInteger("65535", 10);
flow.setCookie(value);
flow.setCookieMask(value);
- flow.setHardTimeout(12);
- flow.setIdleTimeout(34);
+ flow.setHardTimeout(0);
+ flow.setIdleTimeout(0);
flow.setInstallHw(false);
flow.setStrict(false);
flow.setContainerName(null);
- flow.setFlags(new FlowModFlags(false, false, false, false, false));
- flow.setId(new FlowId(new Long(12)));
- flow.setTableId((short) 2);
+ flow.setFlags(new FlowModFlags(false, false, false, false, true));
+ flow.setId(new FlowId("12"));
+ flow.setTableId(getTableId(tableId));
flow.setOutGroup(new Long(2));
- flow.setOutPort(value);
+ // set outport to OFPP_NONE (65535) to disable remove restriction for
+ // flow
+ flow.setOutPort(outputPort);
flow.setKey(key);
flow.setPriority(2);
return flow;
}
+ private short getTableId(String tableId) {
+ short table = 2;
+ try {
+ table = Short.parseShort(tableId);
+ } catch (Exception ex) {
+ // ignore exception and continue with default value
+ }
+
+ return table;
+
+ }
+
/**
* @return
*/
return isb;
}
+ private static InstructionsBuilder createSentToControllerInstructions() {
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+
+ OutputActionBuilder output = new OutputActionBuilder();
+ output.setMaxLength(56);
+ Uri value = new Uri("CONTROLLER");
+ output.setOutputNodeConnector(value);
+ ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
+ ab.setOrder(0);
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+ // Create an Apply Action
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ // Wrap our Apply Action in an Instruction
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+ ib.setOrder(0);
+ ib.setKey(new InstructionKey(0));
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createOutputInstructions(String outputType, int outputValue) {
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+
+ OutputActionBuilder output = new OutputActionBuilder();
+ output.setMaxLength(outputValue);
+ Uri value = new Uri(outputType);
+ output.setOutputNodeConnector(value);
+ ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
+ ab.setOrder(0);
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+ // Create an Apply Action
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ // Wrap our Apply Action in an Instruction
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+ ib.setOrder(0);
+ ib.setKey(new InstructionKey(0));
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createStripVlanInstructions() {
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+
+ StripVlanActionBuilder stripActionBuilder = new StripVlanActionBuilder();
+ ab.setAction(new StripVlanActionCaseBuilder().setStripVlanAction(stripActionBuilder.build()).build());
+ ab.setOrder(0);
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+ // Create an Apply Action
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ // Wrap our Apply Action in an Instruction
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+ ib.setOrder(0);
+ ib.setKey(new InstructionKey(0));
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
private static InstructionsBuilder createAppyActionInstruction2() {
List<Action> actionList = new ArrayList<Action>();
return isb;
}
+ private static InstructionsBuilder createAppyActionInstruction88() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+
+ SetVlanPcpActionBuilder pcp = new SetVlanPcpActionBuilder();
+ VlanPcp pcp1 = new VlanPcp((short) 9);
+ pcp.setVlanPcp(pcp1);
+ ab.setAction(new SetVlanPcpActionCaseBuilder().setSetVlanPcpAction(pcp.build()).build());
+ actionList.add(ab.build());
+ // Create an Apply Action
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ // Wrap our Apply Action in an Instruction
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+
private static InstructionsBuilder createAppyActionInstruction9() {
List<Action> actionList = new ArrayList<Action>();
ActionBuilder ab = new ActionBuilder();
CopyTtlInBuilder ttlin = new CopyTtlInBuilder();
- ab.setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(ttlin.build()).build());
+ ab.setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(ttlin.build()).build());
actionList.add(ab.build());
// Create an Apply Action
ApplyActionsBuilder aab = new ApplyActionsBuilder();
// Wrap our Apply Action in an Instruction
InstructionBuilder ib = new InstructionBuilder();
ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+ ib.setKey(new InstructionKey(0));
+ ib.setOrder(0);
- // Put our Instruction in a list of Instructions
+ // Put our Instruction in a list of Instruction
InstructionsBuilder isb = new InstructionsBuilder();
List<Instruction> instructions = new ArrayList<Instruction>();
instructions.add(ib.build());
return isb;
}
- private static InstructionsBuilder createAppyActionInstruction23() {
+ private static InstructionsBuilder createAppyActionInstruction23(NodeId nodeId) {
List<Action> actionList = new ArrayList<Action>();
ActionBuilder ab = new ActionBuilder();
SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
- setFieldBuilder.setInPort(new Long(2));
+ setFieldBuilder.setInPort(new NodeConnectorId(nodeId + ":2"));
actionList.add(ab.build());
// Create an Apply Action
ActionBuilder ab = new ActionBuilder();
SetNwTosActionBuilder setNwTosActionBuilder = new SetNwTosActionBuilder();
- setNwTosActionBuilder.setTos(1);
+ setNwTosActionBuilder.setTos(8);
ab.setAction(new SetNwTosActionCaseBuilder().setSetNwTosAction(setNwTosActionBuilder.build()).build());
actionList.add(ab.build());
// Create an Apply Action
SetQueueActionBuilder setQueueActionBuilder = new SetQueueActionBuilder();
setQueueActionBuilder.setQueueId(1L);
- ab.setAction(new SetQueueActionCaseBuilder().setSetQueueAction(setQueueActionBuilder.build()).build());
+ ab.setAction(new SetQueueActionCaseBuilder().setSetQueueAction(setQueueActionBuilder.build()).build());
actionList.add(ab.build());
// Create an Apply Action
ApplyActionsBuilder aab = new ApplyActionsBuilder();
isb.setInstruction(instructions);
return isb;
}
-
+
private static InstructionsBuilder createAppyActionInstruction33() {
List<Action> actionList = new ArrayList<Action>();
return isb;
}
- /**
- * @return
- */
- private static MatchBuilder createMatch1() {
- MatchBuilder match = new MatchBuilder();
- Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
- Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1/24");
- ipv4Match.setIpv4Destination(prefix);
- Ipv4Match i4m = ipv4Match.build();
- match.setLayer3Match(i4m);
-
- EthernetMatchBuilder eth = new EthernetMatchBuilder();
- EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
- ethTypeBuilder.setType(new EtherType(0x0800L));
- eth.setEthernetType(ethTypeBuilder.build());
- match.setEthernetMatch(eth.build());
- return match;
- }
+ private static InstructionsBuilder createAppyActionInstruction35() {
- /**
- * @return
- */
- private static MatchBuilder createMatch2() {
- MatchBuilder match = new MatchBuilder();
- Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
- Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1");
- ipv4Match.setIpv4Source(prefix);
- Ipv4Match i4m = ipv4Match.build();
- match.setLayer3Match(i4m);
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ ActionBuilder ab2 = new ActionBuilder();
- EthernetMatchBuilder eth = new EthernetMatchBuilder();
- EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
- ethTypeBuilder.setType(new EtherType(0x0800L));
- eth.setEthernetType(ethTypeBuilder.build());
- match.setEthernetMatch(eth.build());
- return match;
- }
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
- /**
- * @return
- */
- private static MatchBuilder createMatch3() {
- MatchBuilder match = new MatchBuilder();
+ // Ethernet
EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
+ EthernetMatchBuilder ethernetMatch1 = new EthernetMatchBuilder();
+ EthernetDestinationBuilder ethDestBuilder = new EthernetDestinationBuilder();
+ ethDestBuilder.setAddress(new MacAddress("00:00:00:00:00:02"));
+ EthernetMatchBuilder ethernetMatch2 = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0x86ddL));
+
ethernetMatch.setEthernetSource(ethSourceBuilder.build());
- match.setEthernetMatch(ethernetMatch.build());
+ ethernetMatch1.setEthernetDestination(ethDestBuilder.build());
+ ethernetMatch2.setEthernetType(ethTypeBuilder.build());
+ setFieldBuilder.setEthernetMatch(ethernetMatch.build());
+ setFieldBuilder1.setEthernetMatch(ethernetMatch1.build());
+ setFieldBuilder2.setEthernetMatch(ethernetMatch2.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
- return match;
- }
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
- private static MatchBuilder createInphyportMatch() {
- MatchBuilder match = new MatchBuilder();
- match.setInPort(202L);
- match.setInPhyPort(10122L);
- return match;
- }
+ ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
+ ab2.setKey(new ActionKey(2));
+ actionList.add(ab2.build());
- private static MatchBuilder createEthernetMatch() {
- MatchBuilder match = new MatchBuilder();
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
- byte[] mask1 = new byte[] { (byte) -1, (byte) -1, 0, 0, 0, 0 };
- byte[] mask2 = new byte[] { (byte) -1, (byte) -1, (byte) -1, 0, 0, 0 };
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction36() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Vlan
+ VlanMatchBuilder vlanBuilder = new VlanMatchBuilder();
+ VlanMatchBuilder vlanBuilder1 = new VlanMatchBuilder();
+ VlanIdBuilder vlanIdBuilder = new VlanIdBuilder();
+ VlanId vlanId = new VlanId(10);
+ VlanPcp vpcp = new VlanPcp((short) 3);
+ vlanBuilder.setVlanPcp(vpcp);
+ vlanBuilder1.setVlanId(vlanIdBuilder.setVlanId(vlanId).setVlanIdPresent(true).build());
+ setFieldBuilder.setVlanMatch(vlanBuilder.build());
+ setFieldBuilder1.setVlanMatch(vlanBuilder1.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction37() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ ActionBuilder ab2 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
+ // Ip
+ IpMatchBuilder ipmatch = new IpMatchBuilder();
+ IpMatchBuilder ipmatch1 = new IpMatchBuilder();
+ IpMatchBuilder ipmatch2 = new IpMatchBuilder();
+ Dscp dscp = new Dscp((short) 3);
+ ipmatch.setIpDscp(dscp);
+ ipmatch1.setIpEcn((short) 2);
+ ipmatch2.setIpProtocol((short) 120);
+ setFieldBuilder.setIpMatch(ipmatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setIpMatch(ipmatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ setFieldBuilder2.setIpMatch(ipmatch2.build());
+ ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
+ ab2.setKey(new ActionKey(2));
+ actionList.add(ab2.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction38() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ // IPv4
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4MatchBuilder ipv4Match1 = new Ipv4MatchBuilder();
+ Ipv4Prefix dstip = new Ipv4Prefix("200.71.9.5210");
+ Ipv4Prefix srcip = new Ipv4Prefix("100.1.1.1");
+ ipv4Match1.setIpv4Destination(dstip);
+ ipv4Match.setIpv4Source(srcip);
+ setFieldBuilder.setLayer3Match(ipv4Match.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setLayer3Match(ipv4Match1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction39() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Tcp
+ PortNumber tcpsrcport = new PortNumber(1213);
+ PortNumber tcpdstport = new PortNumber(646);
+ TcpMatchBuilder tcpmatch = new TcpMatchBuilder();
+ TcpMatchBuilder tcpmatch1 = new TcpMatchBuilder();
+ tcpmatch.setTcpSourcePort(tcpsrcport);
+ tcpmatch1.setTcpDestinationPort(tcpdstport);
+ setFieldBuilder.setLayer4Match(tcpmatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setLayer4Match(tcpmatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction40() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Udp
+ PortNumber udpsrcport = new PortNumber(1325);
+ PortNumber udpdstport = new PortNumber(42);
+ UdpMatchBuilder udpmatch = new UdpMatchBuilder();
+ UdpMatchBuilder udpmatch1 = new UdpMatchBuilder();
+ udpmatch.setUdpDestinationPort(udpdstport);
+ udpmatch1.setUdpSourcePort(udpsrcport);
+ setFieldBuilder.setLayer4Match(udpmatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setLayer4Match(udpmatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction41() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Sctp
+ SctpMatchBuilder sctpmatch = new SctpMatchBuilder();
+ SctpMatchBuilder sctpmatch1 = new SctpMatchBuilder();
+ PortNumber srcport = new PortNumber(1435);
+ PortNumber dstport = new PortNumber(22);
+ sctpmatch.setSctpSourcePort(srcport);
+ sctpmatch1.setSctpDestinationPort(dstport);
+ setFieldBuilder.setLayer4Match(sctpmatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setLayer4Match(sctpmatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction42() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Icmpv4
+ Icmpv4MatchBuilder icmpv4match = new Icmpv4MatchBuilder();
+ Icmpv4MatchBuilder icmpv4match1 = new Icmpv4MatchBuilder();
+ icmpv4match.setIcmpv4Type((short) 8);
+ icmpv4match1.setIcmpv4Code((short) 0);
+ setFieldBuilder.setIcmpv4Match(icmpv4match.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setIcmpv4Match(icmpv4match1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction43() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ ActionBuilder ab2 = new ActionBuilder();
+ ActionBuilder ab3 = new ActionBuilder();
+ ActionBuilder ab4 = new ActionBuilder();
+
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder3 = new SetFieldBuilder();
+ SetFieldBuilder setFieldBuilder4 = new SetFieldBuilder();
+
+ // setting the values of ARP
+ MacAddress macdest = new MacAddress("ff:ff:ff:ff:ff:ff");
+ MacAddress macsrc = new MacAddress("00:00:00:00:23:ae");
+ Ipv4Prefix dstiparp = new Ipv4Prefix("200.71.9.52");
+ Ipv4Prefix srciparp = new Ipv4Prefix("100.1.1.1");
+ // create ARP match action
+ ArpMatchBuilder arpmatch = new ArpMatchBuilder();
+ ArpMatchBuilder arpmatch1 = new ArpMatchBuilder();
+ ArpMatchBuilder arpmatch2 = new ArpMatchBuilder();
+ ArpMatchBuilder arpmatch3 = new ArpMatchBuilder();
+ ArpMatchBuilder arpmatch4 = new ArpMatchBuilder();
+ ArpSourceHardwareAddressBuilder arpsrc = new ArpSourceHardwareAddressBuilder();
+ arpsrc.setAddress(macsrc);
+ ArpTargetHardwareAddressBuilder arpdst = new ArpTargetHardwareAddressBuilder();
+ arpdst.setAddress(macdest);
+ arpmatch.setArpOp(2);
+ arpmatch1.setArpSourceHardwareAddress(arpsrc.build());
+ arpmatch2.setArpTargetHardwareAddress(arpdst.build());
+ arpmatch3.setArpSourceTransportAddress(srciparp);
+ arpmatch4.setArpTargetTransportAddress(dstiparp);
+ setFieldBuilder.setLayer3Match(arpmatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setLayer3Match(arpmatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ setFieldBuilder2.setLayer3Match(arpmatch2.build());
+ ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
+ ab2.setKey(new ActionKey(2));
+ actionList.add(ab2.build());
+
+ setFieldBuilder3.setLayer3Match(arpmatch3.build());
+ ab3.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder3.build()).build());
+ ab3.setKey(new ActionKey(3));
+ actionList.add(ab3.build());
+
+ setFieldBuilder4.setLayer3Match(arpmatch4.build());
+ ab4.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder4.build()).build());
+ ab4.setKey(new ActionKey(4));
+ actionList.add(ab4.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction44() {
+
+ List<Action> actionLists = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ /* ActionBuilder ab2 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
+ ActionBuilder ab3 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder3 = new SetFieldBuilder();
+ ActionBuilder ab4 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder4 = new SetFieldBuilder(); */
+ ActionBuilder ab5 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder5 = new SetFieldBuilder();
+ ActionBuilder ab6 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder6 = new SetFieldBuilder();
+
+ // IPv6
+ Ipv6MatchBuilder ipv6Builder = new Ipv6MatchBuilder();
+ Ipv6MatchBuilder ipv6Builder1 = new Ipv6MatchBuilder();
+ // Ipv6MatchBuilder ipv6Builder2 = new Ipv6MatchBuilder();
+ // Ipv6MatchBuilder ipv6Builder3 = new Ipv6MatchBuilder();
+ // Ipv6MatchBuilder ipv6Builder4 = new Ipv6MatchBuilder();
+ Ipv6MatchBuilder ipv6Builder5 = new Ipv6MatchBuilder();
+ Ipv6MatchBuilder ipv6Builder6 = new Ipv6MatchBuilder();
+
+ Ipv6Prefix dstip6 = new Ipv6Prefix("2002::2");
+ Ipv6Prefix srcip6 = new Ipv6Prefix("2001:0:0:0:0:0:0:1");
+ // Ipv6Address ndtarget = new Ipv6Address("2001:db8:0:1:fd97:f9f0:a810:782e");
+ // MacAddress ndsll = new MacAddress("c2:00:54:f5:00:00");
+ // MacAddress ndtll = new MacAddress("00:0c:29:0e:4c:67");
+ Ipv6ExtHeaderBuilder nextheader = new Ipv6ExtHeaderBuilder();
+ nextheader.setIpv6Exthdr(58);
+ Ipv6LabelBuilder ipv6label = new Ipv6LabelBuilder();
+ Ipv6FlowLabel label = new Ipv6FlowLabel(10028L);
+ ipv6label.setIpv6Flabel(label);
+
+ ipv6Builder.setIpv6Source(srcip6);
+ ipv6Builder1.setIpv6Destination(dstip6);
+ // ipv6Builder2.setIpv6NdTarget(ndtarget);
+ // ipv6Builder3.setIpv6NdSll(ndsll);
+ // ipv6Builder4.setIpv6NdTll(ndtll);
+ ipv6Builder5.setIpv6ExtHeader(nextheader.build());
+ ipv6Builder6.setIpv6Label(ipv6label.build());
+
+ setFieldBuilder.setLayer3Match(ipv6Builder.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionLists.add(ab.build());
+
+ setFieldBuilder1.setLayer3Match(ipv6Builder1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionLists.add(ab1.build());
+
+ /* setFieldBuilder2.setLayer3Match(ipv6Builder2.build());
+ ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
+ ab2.setKey(new ActionKey(2));
+ actionLists.add(ab2.build());
+
+ setFieldBuilder3.setLayer3Match(ipv6Builder3.build());
+ ab3.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder3.build()).build());
+ ab3.setKey(new ActionKey(3));
+ actionLists.add(ab3.build());
+
+ setFieldBuilder4.setLayer3Match(ipv6Builder4.build());
+ ab4.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder4.build()).build());
+ ab4.setKey(new ActionKey(4));
+ actionLists.add(ab4.build());
+*/
+ setFieldBuilder5.setLayer3Match(ipv6Builder5.build());
+ ab5.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder5.build()).build());
+ ab5.setKey(new ActionKey(5));
+ actionLists.add(ab5.build());
+
+ setFieldBuilder6.setLayer3Match(ipv6Builder6.build());
+ ab6.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder6.build()).build());
+ ab6.setKey(new ActionKey(6));
+ actionLists.add(ab6.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionLists);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
- EthernetMatchBuilder ethmatch = new EthernetMatchBuilder(); // ethernettype
- // match
- EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
- EtherType type = new EtherType(0x0800L);
- ethmatch.setEthernetType(ethtype.setType(type).build());
+
+ private static InstructionsBuilder createAppyActionInstruction45() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+
+ // Icmpv6
+ Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder();
+ Icmpv6MatchBuilder icmpv6match1 = new Icmpv6MatchBuilder();
+ icmpv6match.setIcmpv6Type((short) 135);
+ icmpv6match1.setIcmpv6Code((short) 0);
+ setFieldBuilder.setIcmpv6Match(icmpv6match.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setIcmpv6Match(icmpv6match1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction46() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ ActionBuilder ab1 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
+ ActionBuilder ab2 = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
+
+ // MPLS
+ ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder();
+ ProtocolMatchFieldsBuilder protomatch1 = new ProtocolMatchFieldsBuilder();
+ ProtocolMatchFieldsBuilder protomatch2 = new ProtocolMatchFieldsBuilder();
+ protomatch.setMplsLabel((long) 36008);
+ protomatch1.setMplsTc((short) 4);
+ protomatch2.setMplsBos((short) 1);
+ setFieldBuilder.setProtocolMatchFields(protomatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ ab.setKey(new ActionKey(0));
+ actionList.add(ab.build());
+
+ setFieldBuilder1.setProtocolMatchFields(protomatch1.build());
+ ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
+ ab1.setKey(new ActionKey(1));
+ actionList.add(ab1.build());
+
+ setFieldBuilder2.setProtocolMatchFields(protomatch2.build());
+ ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
+ ab2.setKey(new ActionKey(2));
+ actionList.add(ab2.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction47() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ // PBB
+ ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder();
+ protomatch.setPbb(new PbbBuilder().setPbbIsid(4L).setPbbMask(new byte[] { 0, 1, 0, 0 }).build());
+ setFieldBuilder.setProtocolMatchFields(protomatch.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ actionList.add(ab.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ private static InstructionsBuilder createAppyActionInstruction48() {
+
+ List<Action> actionList = new ArrayList<Action>();
+ ActionBuilder ab = new ActionBuilder();
+ SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
+ // Tunnel
+ TunnelBuilder tunnel = new TunnelBuilder();
+ tunnel.setTunnelId(BigInteger.valueOf(10668));
+ setFieldBuilder.setTunnel(tunnel.build());
+ ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
+ actionList.add(ab.build());
+
+ ApplyActionsBuilder aab = new ApplyActionsBuilder();
+ aab.setAction(actionList);
+
+ InstructionBuilder ib = new InstructionBuilder();
+ ib.setKey(new InstructionKey(0));
+ ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
+
+ // Put our Instruction in a list of Instructions
+ InstructionsBuilder isb = new InstructionsBuilder();
+ List<Instruction> instructions = new ArrayList<Instruction>();
+ instructions.add(ib.build());
+ isb.setInstruction(instructions);
+ return isb;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createMatch1() {
+ MatchBuilder match = new MatchBuilder();
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1/24");
+ ipv4Match.setIpv4Destination(prefix);
+ Ipv4Match i4m = ipv4Match.build();
+ match.setLayer3Match(i4m);
+
+ EthernetMatchBuilder eth = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0x0800L));
+ eth.setEthernetType(ethTypeBuilder.build());
+ match.setEthernetMatch(eth.build());
+ return match;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createIPv4DstMatch() {
+ MatchBuilder match = new MatchBuilder();
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1/24");
+ ipv4Match.setIpv4Destination(prefix);
+ Ipv4Match i4m = ipv4Match.build();
+ match.setLayer3Match(i4m);
+
+ return match;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createIPv4SrcMatch() {
+ MatchBuilder match = new MatchBuilder();
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4Prefix prefix = new Ipv4Prefix("10.20.30.40/24");
+ ipv4Match.setIpv4Source(prefix);
+ Ipv4Match i4m = ipv4Match.build();
+ match.setLayer3Match(i4m);
+
+ EthernetMatchBuilder eth = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0x0800L));
+ eth.setEthernetType(ethTypeBuilder.build());
+ match.setEthernetMatch(eth.build());
+ return match;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createMatch2() {
+ MatchBuilder match = new MatchBuilder();
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1");
+ ipv4Match.setIpv4Source(prefix);
+ Ipv4Match i4m = ipv4Match.build();
+ match.setLayer3Match(i4m);
+
+ EthernetMatchBuilder eth = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0x0800L));
+ eth.setEthernetType(ethTypeBuilder.build());
+ match.setEthernetMatch(eth.build());
+ return match;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createMatch3() {
+ MatchBuilder match = new MatchBuilder();
+ EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
+ EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
+ ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
+ ethernetMatch.setEthernetSource(ethSourceBuilder.build());
+ match.setEthernetMatch(ethernetMatch.build());
+
+ return match;
+ }
+
+ /**
+ * @return
+ */
+ private static MatchBuilder createICMPv6Match1() {
+
+ MatchBuilder match = new MatchBuilder();
+ EthernetMatchBuilder eth = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0x86ddL));
+ eth.setEthernetType(ethTypeBuilder.build());
+ match.setEthernetMatch(eth.build());
+
+ IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
+ ipmatch.setIpProtocol((short) 256);
+ match.setIpMatch(ipmatch.build());
+
+ Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder(); // icmpv6
+ // match
+ icmpv6match.setIcmpv6Type((short) 135);
+ icmpv6match.setIcmpv6Code((short) 1);
+ match.setIcmpv6Match(icmpv6match.build());
+
+ return match;
+ }
+
+ private static MatchBuilder createMatch33() {
+
+ MatchBuilder match = new MatchBuilder();
+ Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
+ Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.10");
+ ipv4Match.setIpv4Source(prefix);
+ Ipv4Match i4m = ipv4Match.build();
+ match.setLayer3Match(i4m);
+
+ EthernetMatchBuilder eth = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
+ ethTypeBuilder.setType(new EtherType(0xfffeL));
+ eth.setEthernetType(ethTypeBuilder.build());
+ match.setEthernetMatch(eth.build());
+ return match;
+ }
+
+ private static MatchBuilder createInphyportMatch(NodeId nodeId) {
+ MatchBuilder match = new MatchBuilder();
+ match.setInPort(new NodeConnectorId(nodeId+":202"));
+ match.setInPhyPort(new NodeConnectorId(nodeId+":10122"));
+ return match;
+ }
+
+ private static MatchBuilder createEthernetMatch() {
+ MatchBuilder match = new MatchBuilder();
+
+ byte[] mask1 = new byte[] { (byte) -1, (byte) -1, 0, 0, 0, 0 };
+ byte[] mask2 = new byte[] { (byte) -1, (byte) -1, (byte) -1, 0, 0, 0 };
+
+ EthernetMatchBuilder ethmatch = new EthernetMatchBuilder(); // ethernettype
+ // match
+ EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
+ EtherType type = new EtherType(0x0800L);
+ ethmatch.setEthernetType(ethtype.setType(type).build());
EthernetDestinationBuilder ethdest = new EthernetDestinationBuilder(); // ethernet
// macaddress
return match;
}
+ /**
+ * @return
+ */
+ private static MatchBuilder createToSMatch() {
+ MatchBuilder match = new MatchBuilder();
+ EthernetMatchBuilder ethmatch = new EthernetMatchBuilder();
+ EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
+ EtherType type = new EtherType(0x0800L);
+ ethmatch.setEthernetType(ethtype.setType(type).build());
+ match.setEthernetMatch(ethmatch.build());
+
+ IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
+ ipmatch.setIpProtocol((short) 6);
+ Dscp dscp = new Dscp((short) 8);
+ ipmatch.setIpDscp(dscp);
+ match.setIpMatch(ipmatch.build());
+ return match;
+ }
+
/**
* @return
*/
public void _removeMDFlow(CommandInterpreter ci) {
DataModification<InstanceIdentifier<?>, DataObject> modification = dataBrokerService.beginTransaction();
NodeBuilder tn = createTestNode(ci.nextArgument());
- FlowBuilder tf = createTestFlow(tn, ci.nextArgument());
- InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class)
- .child(Node.class, tn.getKey()).augmentation(FlowCapableNode.class)
- .child(Table.class, new TableKey(tf.getTableId())).child(Flow.class, tf.getKey())
- .build();
+ FlowBuilder tf = createTestFlow(tn, ci.nextArgument(), ci.nextArgument());
+ InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class).child(Node.class, tn.getKey())
+ .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf.getTableId()))
+ .child(Flow.class, tf.getKey()).build();
modification.removeOperationalData(nodeBuilderToInstanceId(tn));
modification.removeOperationalData(path1);
modification.removeConfigurationData(nodeBuilderToInstanceId(tn));
ci.println("Status of Flow Data Loaded Transaction: " + status);
} catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ LOG.error(e.getMessage(), e);
} catch (ExecutionException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ LOG.error(e.getMessage(), e);
}
}
public void _addMDFlow(CommandInterpreter ci) {
NodeBuilder tn = createTestNode(ci.nextArgument());
- FlowBuilder tf = createTestFlow(tn, ci.nextArgument());
+ FlowBuilder tf = createTestFlow(tn, ci.nextArgument(), ci.nextArgument());
writeFlow(ci, tf, tn);
}
DataModification<InstanceIdentifier<?>, DataObject> modification = dataBrokerService.beginTransaction();
InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class)
- .child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flow.getKey())
- .build();
+ .child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flow.getKey()).build();
modification.putOperationalData(nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build());
modification.putOperationalData(path1, flow.build());
modification.putConfigurationData(nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build());
ci.println("Status of Flow Data Loaded Transaction: " + status);
} catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ LOG.error(e.getMessage(), e);
} catch (ExecutionException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ LOG.error(e.getMessage(), e);
}
}
public void _modifyMDFlow(CommandInterpreter ci) {
NodeBuilder tn = createTestNode(ci.nextArgument());
- FlowBuilder tf = createTestFlow(tn, ci.nextArgument());
+ FlowBuilder tf = createTestFlow(tn, ci.nextArgument(), ci.nextArgument());
tf.setFlowName(updatedFlowName);
writeFlow(ci, tf, tn);
tf.setFlowName(originalFlowName);