test-provider/src/main/java/org/opendaylight/openflowplugin/test/OpenflowPluginBulkGroupTransactionProvider.java

   1 package org.opendaylight.openflowplugin.test;
   2
   3 import java.math.BigInteger;
   4 import java.util.ArrayList;
   5 import java.util.List;
   6 import java.util.concurrent.ExecutionException;
   7 import java.util.concurrent.Future;
   8
   9 import org.eclipse.osgi.framework.console.CommandInterpreter;
  10 import org.eclipse.osgi.framework.console.CommandProvider;
  11 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  12 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  13 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  14 import org.opendaylight.controller.sal.binding.api.NotificationService;
  15 import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.ControllerActionCaseBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlOutCaseBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecMplsTtlCaseBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecNwTtlCaseBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCaseBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopPbbActionCaseBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCaseBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCaseBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCaseBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanIdActionCaseBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.controller.action._case.ControllerActionBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlInBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.out._case.CopyTtlOutBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.mpls.ttl._case.DecMplsTtlBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtl;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtlBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropAction;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropActionBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupActionBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.pbb.action._case.PopPbbActionBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbActionBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.id.action._case.SetVlanIdActionBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.GoToTableCaseBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.MeterCaseBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.meter._case.MeterBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketKey;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.node.error.service.rev140410.NodeErrorListener;
  95 import org.opendaylight.yangtools.concepts.Registration;
  96 import org.opendaylight.yangtools.yang.binding.DataObject;
  97 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  98 import org.opendaylight.yangtools.yang.common.RpcResult;
  99 import org.osgi.framework.BundleContext;
 100 import org.slf4j.Logger;
 101 import org.slf4j.LoggerFactory;
 102
 103 //import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.M
 104
 105 public class OpenflowPluginBulkGroupTransactionProvider implements CommandProvider {
 106     private static final Logger LOG = LoggerFactory.getLogger(OpenflowPluginBulkGroupTransactionProvider.class);
 107     private NodeBuilder testNode;
 108     private DataBrokerService dataBrokerService;
 109     private final BundleContext ctx;
 110     private ProviderContext pc;
 111     private FlowBuilder testFlow;
 112     private final String originalFlowName = "Foo";
 113     private final NodeErrorListener nodeErrorListener = new NodeErrorListenerLoggingImpl();
 114     private Registration<org.opendaylight.yangtools.yang.binding.NotificationListener> listener1Reg;
 115     private Registration<org.opendaylight.yangtools.yang.binding.NotificationListener> listener2Reg;
 116     private Group testGroup;
 117     private Group testGroup2;
 118     private Node testNode12;
 119     private final String originalGroupName = "Foo";
 120     private static NotificationService notificationService;
 121
 122     public OpenflowPluginBulkGroupTransactionProvider(BundleContext ctx) {
 123         this.ctx = ctx;
 124     }
 125
 126     public void onSessionInitiated(ProviderContext session) {
 127         pc = session;
 128         notificationService = session.getSALService(NotificationService.class);
 129         listener2Reg = notificationService.registerNotificationListener(nodeErrorListener);
 130         dataBrokerService = session.getSALService(DataBrokerService.class);
 131         ctx.registerService(CommandProvider.class.getName(), this, null);
 132         createTestFlow(createTestNode(null), null, null);
 133     }
 134
 135     private NodeBuilder createTestNode(String nodeId) {
 136         if (nodeId == null) {
 137             nodeId = OpenflowpluginTestActivator.NODE_ID;
 138         }
 139         NodeRef nodeOne = createNodeRef(nodeId);
 140         NodeBuilder builder = new NodeBuilder();
 141         builder.setId(new NodeId(nodeId));
 142         builder.setKey(new NodeKey(builder.getId()));
 143         testNode = builder;
 144         return builder;
 145     }
 146
 147     private static NodeRef createNodeRef(String string) {
 148         NodeKey key = new NodeKey(new NodeId(string));
 149         InstanceIdentifier<Node> path = InstanceIdentifier.builder(Nodes.class).child(Node.class, key)
 150                 .toInstance();
 151
 152         return new NodeRef(path);
 153     }
 154
 155     @Override
 156     public String getHelp() {
 157         return "No help";
 158     }
 159
 160     /**
 161      * @return
 162      */
 163     private static MatchBuilder createMatch1() {
 164         MatchBuilder match = new MatchBuilder();
 165         Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
 166         Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1/24");
 167         ipv4Match.setIpv4Destination(prefix);
 168         Ipv4Match i4m = ipv4Match.build();
 169         match.setLayer3Match(i4m);
 170
 171         EthernetMatchBuilder eth = new EthernetMatchBuilder();
 172         EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
 173         ethTypeBuilder.setType(new EtherType(0x0800L));
 174         eth.setEthernetType(ethTypeBuilder.build());
 175         match.setEthernetMatch(eth.build());
 176         return match;
 177     }
 178
 179     /**
 180      * @return
 181      */
 182     private static InstructionsBuilder createDecNwTtlInstructions() {
 183         DecNwTtlBuilder ta = new DecNwTtlBuilder();
 184         DecNwTtl decNwTtl = ta.build();
 185         ActionBuilder ab = new ActionBuilder();
 186         ab.setAction(new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build());
 187
 188         // Add our drop action to a list
 189         List<Action> actionList = new ArrayList<Action>();
 190         actionList.add(ab.build());
 191
 192         // Create an Apply Action
 193         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 194         aab.setAction(actionList);
 195
 196         // Wrap our Apply Action in an Instruction
 197         InstructionBuilder ib = new InstructionBuilder();
 198         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 199         ib.setKey(new InstructionKey(0));
 200         ib.setOrder(0);
 201
 202         // Put our Instruction in a list of Instructions
 203         InstructionsBuilder isb = new InstructionsBuilder();
 204         List<Instruction> instructions = new ArrayList<Instruction>();
 205         instructions.add(ib.build());
 206         isb.setInstruction(instructions);
 207         return isb;
 208     }
 209
 210     /**
 211      * @return
 212      */
 213     private static MatchBuilder createMatch2() {
 214         MatchBuilder match = new MatchBuilder();
 215         Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
 216         Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1");
 217         ipv4Match.setIpv4Source(prefix);
 218         Ipv4Match i4m = ipv4Match.build();
 219         match.setLayer3Match(i4m);
 220
 221         EthernetMatchBuilder eth = new EthernetMatchBuilder();
 222         EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
 223         ethTypeBuilder.setType(new EtherType(0x0800L));
 224         eth.setEthernetType(ethTypeBuilder.build());
 225         match.setEthernetMatch(eth.build());
 226         return match;
 227     }
 228
 229     /**
 230      * @return
 231      */
 232     private static MatchBuilder createMatch3() {
 233         MatchBuilder match = new MatchBuilder();
 234         EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
 235         EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
 236         ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
 237         ethernetMatch.setEthernetSource(ethSourceBuilder.build());
 238         match.setEthernetMatch(ethernetMatch.build());
 239
 240         return match;
 241     }
 242
 243     private static InstructionsBuilder createDropInstructions() {
 244         DropActionBuilder dab = new DropActionBuilder();
 245         DropAction dropAction = dab.build();
 246         ActionBuilder ab = new ActionBuilder();
 247         ab.setAction(new DropActionCaseBuilder().setDropAction(dropAction).build());
 248
 249         // Add our drop action to a list
 250         List<Action> actionList = new ArrayList<Action>();
 251         actionList.add(ab.build());
 252
 253         // Create an Apply Action
 254         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 255         aab.setAction(actionList);
 256
 257         // Wrap our Apply Action in an Instruction
 258         InstructionBuilder ib = new InstructionBuilder();
 259         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 260
 261         // Put our Instruction in a list of Instructions
 262         InstructionsBuilder isb = new InstructionsBuilder();
 263         List<Instruction> instructions = new ArrayList<Instruction>();
 264         instructions.add(ib.build());
 265         isb.setInstruction(instructions);
 266         return isb;
 267     }
 268
 269     private static MatchBuilder createEthernetMatch() {
 270         MatchBuilder match = new MatchBuilder();
 271
 272         byte[] mask1 = new byte[] { (byte) -1, (byte) -1, 0, 0, 0, 0 };
 273         byte[] mask2 = new byte[] { (byte) -1, (byte) -1, (byte) -1, 0, 0, 0 };
 274
 275         EthernetMatchBuilder ethmatch = new EthernetMatchBuilder(); // ethernettype
 276                                                                     // match
 277         EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
 278         EtherType type = new EtherType(0x0800L);
 279         ethmatch.setEthernetType(ethtype.setType(type).build());
 280
 281         EthernetDestinationBuilder ethdest = new EthernetDestinationBuilder(); // ethernet
 282                                                                                // macaddress
 283                                                                                // match
 284         MacAddress macdest = new MacAddress("ff:ff:ff:ff:ff:ff");
 285         ethdest.setAddress(macdest);
 286         // ethdest.setMask(mask1);
 287
 288         ethmatch.setEthernetDestination(ethdest.build());
 289
 290         EthernetSourceBuilder ethsrc = new EthernetSourceBuilder();
 291         MacAddress macsrc = new MacAddress("00:00:00:00:23:ae");
 292         ethsrc.setAddress(macsrc);
 293         // ethsrc.setMask(mask2);
 294
 295         ethmatch.setEthernetSource(ethsrc.build());
 296         match.setEthernetMatch(ethmatch.build());
 297         return match;
 298
 299     }
 300
 301     /**
 302      * @return
 303      */
 304     private static InstructionsBuilder createMeterInstructions() {
 305
 306         MeterBuilder aab = new MeterBuilder();
 307         aab.setMeterId(new MeterId(new Long(1)));
 308
 309         InstructionBuilder ib = new InstructionBuilder();
 310         ib.setInstruction(new MeterCaseBuilder().setMeter(aab.build()).build());
 311
 312         // Put our Instruction in a list of Instructions
 313         InstructionsBuilder isb = new InstructionsBuilder();
 314         List<Instruction> instructions = new ArrayList<Instruction>();
 315         instructions.add(ib.build());
 316         isb.setInstruction(instructions);
 317         return isb;
 318     }
 319
 320     private static InstructionsBuilder createAppyActionInstruction() {
 321
 322         List<Action> actionList = new ArrayList<Action>();
 323         ActionBuilder ab = new ActionBuilder();
 324         ControllerActionBuilder controller = new ControllerActionBuilder();
 325         controller.setMaxLength(5);
 326         ab.setAction(new ControllerActionCaseBuilder().setControllerAction(controller.build()).build());
 327         actionList.add(ab.build());
 328         // Create an Apply Action
 329         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 330         aab.setAction(actionList);
 331
 332         // Wrap our Apply Action in an Instruction
 333         InstructionBuilder ib = new InstructionBuilder();
 334         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 335
 336         // Put our Instruction in a list of Instructions
 337         InstructionsBuilder isb = new InstructionsBuilder();
 338         List<Instruction> instructions = new ArrayList<Instruction>();
 339         instructions.add(ib.build());
 340         isb.setInstruction(instructions);
 341         return isb;
 342     }
 343
 344     private static InstructionsBuilder createAppyActionInstruction7() {
 345
 346         List<Action> actionList = new ArrayList<Action>();
 347         ActionBuilder ab = new ActionBuilder();
 348
 349         SetVlanIdActionBuilder vl = new SetVlanIdActionBuilder();
 350         VlanId a = new VlanId(4012);
 351         vl.setVlanId(a);
 352         ab.setAction(new SetVlanIdActionCaseBuilder().setSetVlanIdAction(vl.build()).build());
 353         actionList.add(ab.build());
 354         // Create an Apply Action
 355         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 356         aab.setAction(actionList);
 357
 358         // Wrap our Apply Action in an Instruction
 359         InstructionBuilder ib = new InstructionBuilder();
 360         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 361
 362         // Put our Instruction in a list of Instructions
 363         InstructionsBuilder isb = new InstructionsBuilder();
 364         List<Instruction> instructions = new ArrayList<Instruction>();
 365         instructions.add(ib.build());
 366         isb.setInstruction(instructions);
 367         return isb;
 368     }
 369
 370     private static InstructionsBuilder createAppyActionInstruction21() {
 371
 372         List<Action> actionList = new ArrayList<Action>();
 373         ActionBuilder ab = new ActionBuilder();
 374
 375         PopVlanActionBuilder popVlanActionBuilder = new PopVlanActionBuilder();
 376         ab.setAction(new PopVlanActionCaseBuilder().setPopVlanAction(popVlanActionBuilder.build()).build());
 377         actionList.add(ab.build());
 378
 379         // Create an Apply Action
 380         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 381         aab.setAction(actionList);
 382
 383         // Wrap our Apply Action in an Instruction
 384         InstructionBuilder ib = new InstructionBuilder();
 385         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 386
 387         // Put our Instruction in a list of Instructions
 388         InstructionsBuilder isb = new InstructionsBuilder();
 389         List<Instruction> instructions = new ArrayList<Instruction>();
 390         instructions.add(ib.build());
 391         isb.setInstruction(instructions);
 392         return isb;
 393     }
 394
 395     private static InstructionsBuilder createAppyActionInstruction2() {
 396
 397         List<Action> actionList = new ArrayList<Action>();
 398         ActionBuilder ab = new ActionBuilder();
 399
 400         PushMplsActionBuilder push = new PushMplsActionBuilder();
 401         push.setEthernetType(new Integer(0x8847));
 402         ab.setAction(new PushMplsActionCaseBuilder().setPushMplsAction(push.build()).build());
 403         actionList.add(ab.build());
 404         // Create an Apply Action
 405         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 406         aab.setAction(actionList);
 407
 408         // Wrap our Apply Action in an Instruction
 409         InstructionBuilder ib = new InstructionBuilder();
 410         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 411
 412         // Put our Instruction in a list of Instructions
 413         InstructionsBuilder isb = new InstructionsBuilder();
 414         List<Instruction> instructions = new ArrayList<Instruction>();
 415         instructions.add(ib.build());
 416         isb.setInstruction(instructions);
 417         return isb;
 418     }
 419
 420     private static InstructionsBuilder createAppyActionInstruction3() {
 421
 422         List<Action> actionList = new ArrayList<Action>();
 423         ActionBuilder ab = new ActionBuilder();
 424
 425         PushPbbActionBuilder pbb = new PushPbbActionBuilder();
 426         pbb.setEthernetType(new Integer(0x88E7));
 427         ab.setAction(new PushPbbActionCaseBuilder().setPushPbbAction(pbb.build()).build());
 428         actionList.add(ab.build());
 429         // Create an Apply Action
 430         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 431         aab.setAction(actionList);
 432
 433         // Wrap our Apply Action in an Instruction
 434         InstructionBuilder ib = new InstructionBuilder();
 435         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 436
 437         // Put our Instruction in a list of Instructions
 438         InstructionsBuilder isb = new InstructionsBuilder();
 439         List<Instruction> instructions = new ArrayList<Instruction>();
 440         instructions.add(ib.build());
 441         isb.setInstruction(instructions);
 442         return isb;
 443     }
 444
 445     private static InstructionsBuilder createGotoTableInstructions() {
 446
 447         GoToTableBuilder aab = new GoToTableBuilder();
 448         aab.setTableId((short) 2);
 449
 450         InstructionBuilder ib = new InstructionBuilder();
 451         ib.setInstruction(new GoToTableCaseBuilder().setGoToTable(aab.build()).build());
 452
 453         // Put our Instruction in a list of Instructions
 454         InstructionsBuilder isb = new InstructionsBuilder();
 455         List<Instruction> instructions = new ArrayList<Instruction>();
 456         instructions.add(ib.build());
 457         isb.setInstruction(instructions);
 458         return isb;
 459     }
 460
 461     private FlowBuilder createTestFlow(NodeBuilder nodeBuilder, String flowTypeArg, String tableId) {
 462
 463         FlowBuilder flow = new FlowBuilder();
 464         long id = 123;
 465
 466         String flowType = flowTypeArg;
 467         if (flowType == null) {
 468             flowType = "f1";
 469         }
 470
 471         switch (flowType) {
 472         case "f1":
 473             id += 1;
 474             flow.setMatch(createMatch1().build());
 475             flow.setInstructions(createDecNwTtlInstructions().build());
 476             break;
 477         case "f2":
 478             id += 2;
 479             flow.setMatch(createMatch2().build());
 480             flow.setInstructions(createDropInstructions().build());
 481             break;
 482         case "f3":
 483             id += 3;
 484             flow.setMatch(createMatch3().build());
 485             flow.setInstructions(createDropInstructions().build());
 486             break;
 487         case "f4":
 488             id += 4;
 489             flow.setMatch(createEthernetMatch().build());
 490             flow.setInstructions(createDropInstructions().build());
 491             break;
 492         case "f82":
 493             id += 1;
 494             flow.setMatch(createMatch1().build());
 495             flow.setInstructions(createDropInstructions().build());
 496             break;
 497         case "f5":
 498             id += 5;
 499             flow.setMatch(createMatch1().build());
 500             flow.setInstructions(createAppyActionInstruction().build());
 501             break;
 502         case "f6":
 503             id += 6;
 504             flow.setMatch(createMatch1().build());
 505             flow.setInstructions(createGotoTableInstructions().build());
 506             break;
 507         case "f7":
 508             id += 7;
 509             flow.setMatch(createMatch1().build());
 510             flow.setInstructions(createMeterInstructions().build());
 511             break;
 512         case "f8":
 513             id += 8;
 514             flow.setMatch(createMatch1().build());
 515             flow.setInstructions(createAppyActionInstruction7().build());
 516             break;
 517         case "f9":
 518             id += 9;
 519             flow.setMatch(createMatch1().build());
 520             flow.setInstructions(createAppyActionInstruction2().build());
 521             break;
 522         case "f10":
 523             id += 10;
 524             flow.setMatch(createMatch1().build());
 525             flow.setInstructions(createAppyActionInstruction3().build());
 526             break;
 527         case "f14":
 528             id += 14;
 529             flow.setMatch(createMatch1().build());
 530             flow.setInstructions(createAppyActionInstruction7().build());
 531             break;
 532         case "f29":
 533             id += 29;
 534             flow.setMatch(createMatch1().build());
 535             flow.setInstructions(createAppyActionInstruction21().build());
 536             break;
 537
 538         default:
 539             LOG.warn("flow type not understood: {}", flowType);
 540         }
 541
 542         FlowKey key = new FlowKey(new FlowId(Long.toString(id)));
 543         if (null == flow.isBarrier()) {
 544             flow.setBarrier(Boolean.FALSE);
 545         }
 546         // flow.setBufferId(new Long(12));
 547         BigInteger value = new BigInteger("10", 10);
 548         BigInteger outputPort = new BigInteger("4294967295", 10);
 549         flow.setCookie(new FlowCookie(value));
 550         flow.setCookieMask(new FlowCookie(value));
 551         flow.setHardTimeout(0);
 552         flow.setIdleTimeout(0);
 553         flow.setInstallHw(false);
 554         flow.setStrict(false);
 555         flow.setContainerName(null);
 556         flow.setFlags(new FlowModFlags(false, false, false, false, true));
 557         flow.setId(new FlowId("12"));
 558         flow.setTableId(getTableId(tableId));
 559         flow.setOutGroup(new Long("4294967295"));
 560         // set outport to OFPP_NONE (65535) to disable remove restriction for
 561         // flow
 562         flow.setOutPort(outputPort);
 563
 564         flow.setKey(key);
 565         flow.setPriority(2);
 566         flow.setFlowName(originalFlowName + "X" + flowType);
 567         testFlow = flow;
 568         return flow;
 569     }
 570
 571     private short getTableId(String tableId) {
 572         short table = 2;
 573         try {
 574             table = Short.parseShort(tableId);
 575         } catch (Exception ex) {
 576             // ignore exception and continue with default value
 577         }
 578
 579         return table;
 580
 581     }
 582
 583     public void _addGroups(CommandInterpreter ci) {
 584         String nref = ci.nextArgument();
 585
 586         if (nref == null) {
 587             ci.println("test node added");
 588             createTestNode();
 589         } else {
 590             ci.println("User node added" + nref);
 591             createUserNode(nref);
 592         }
 593         Integer count = Integer.parseInt(ci.nextArgument());
 594         switch (count) {
 595         case 1:
 596             GroupBuilder group = createTestGroup("a7", "g1", "add", "1");
 597             GroupBuilder group1 = createTestGroup("a3", "g1", "add", "2");
 598             writeGroup(ci, group.build(), group1.build());
 599             break;
 600         case 2:
 601             GroupBuilder group2 = createTestGroup("a4", "g1", "add", "4");
 602             GroupBuilder group3 = createTestGroup("a5", "g1", "add", "5");
 603             writeGroup(ci, group2.build(), group3.build());
 604             break;
 605         case 3:
 606             GroupBuilder group4 = createTestGroup("a6", "g1", "add", "6");
 607             GroupBuilder group5 = createTestGroup("a7", "g1", "add", "7");
 608             writeGroup(ci, group4.build(), group5.build());
 609             break;
 610         case 4:
 611             // -ve
 612             GroupBuilder group6 = createTestGroup("a14", "g1", "add", "5");
 613             GroupBuilder group7 = createTestGroup("a3", "g1", "add", "6");
 614             writeGroup(ci, group6.build(), group7.build());
 615             break;
 616
 617         }
 618
 619     }
 620
 621     private void createUserNode(String nodeRef) {
 622         NodeRef nodeOne = createNodeRef(nodeRef);
 623         NodeBuilder builder = new NodeBuilder();
 624         builder.setId(new NodeId(nodeRef));
 625         builder.setKey(new NodeKey(builder.getId()));
 626         testNode12 = builder.build();
 627     }
 628
 629     public void _modifyGroups(CommandInterpreter ci) {
 630         String nref = ci.nextArgument();
 631
 632         if (nref == null) {
 633             ci.println("test node added");
 634             createTestNode();
 635         } else {
 636             ci.println("User node added" + nref);
 637             createUserNode(nref);
 638         }
 639         Integer count = Integer.parseInt(ci.nextArgument());
 640         switch (count) {
 641         case 1:
 642             GroupBuilder group = createTestGroup("a4", "g1", "modify", "1");
 643             GroupBuilder group1 = createTestGroup("a5", "g1", "modify", "2");
 644             writeGroup(ci, group.build(), group1.build());
 645             break;
 646         case 2:
 647             GroupBuilder group2 = createTestGroup("a1", "g1", "modify", "4");
 648             GroupBuilder group3 = createTestGroup("a2", "g1", "modify", "5");
 649             writeGroup(ci, group2.build(), group3.build());
 650             break;
 651         case 3:
 652             GroupBuilder group4 = createTestGroup("a9", "g1", "modify", "6");
 653             GroupBuilder group5 = createTestGroup("a10", "g1", "modify", "7");
 654             writeGroup(ci, group4.build(), group5.build());
 655             break;
 656
 657         case 4:
 658             GroupBuilder group6 = createTestGroup("a6", "g1", "modify", "5");
 659             GroupBuilder group7 = createTestGroup("a29", "g1", "modify", "6");
 660             writeGroup(ci, group6.build(), group7.build());
 661             break;
 662         }
 663     }
 664
 665     private InstanceIdentifier<Node> nodeToInstanceId(Node node) {
 666         return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
 667     }
 668
 669     private void createTestNode() {
 670         NodeRef nodeOne = createNodeRef(OpenflowpluginTestActivator.NODE_ID);
 671         NodeBuilder builder = new NodeBuilder();
 672         builder.setId(new NodeId(OpenflowpluginTestActivator.NODE_ID));
 673         builder.setKey(new NodeKey(builder.getId()));
 674         testNode12 = builder.build();
 675     }
 676
 677     public void _removeGroups(CommandInterpreter ci) {
 678         String nref = ci.nextArgument();
 679
 680         if (nref == null) {
 681             ci.println("test node added");
 682             createTestNode();
 683         } else {
 684             ci.println("User node added" + nref);
 685             createUserNode(nref);
 686         }
 687
 688         Integer count = Integer.parseInt(ci.nextArgument());
 689         switch (count) {
 690         case 1:
 691             GroupBuilder group = createTestGroup("a2", "g1", "remove", "1");
 692             GroupBuilder group1 = createTestGroup("a3", "g1", "remove", "2");
 693             deleteGroup(ci, group.build(), group1.build());
 694             break;
 695         case 2:
 696             GroupBuilder group2 = createTestGroup("a4", "g1", "remove", "4");
 697             GroupBuilder group3 = createTestGroup("a5", "g1", "remove", "5");
 698             deleteGroup(ci, group2.build(), group3.build());
 699             break;
 700         case 3:
 701             GroupBuilder group4 = createTestGroup("a6", "g1", "remove", "6");
 702             GroupBuilder group5 = createTestGroup("a7", "g1", "remove", "7");
 703             deleteGroup(ci, group4.build(), group5.build());
 704             break;
 705         case 4:
 706             GroupBuilder group6 = createTestGroup("a14", "g1", "remove", "5");
 707             GroupBuilder group7 = createTestGroup("a3", "g1", "remove", "6");
 708             deleteGroup(ci, group6.build(), group7.build());
 709             break;
 710         case 5:
 711             GroupBuilder group8 = createTestGroup("a4", "g1", "modify", "1");
 712             GroupBuilder group9 = createTestGroup("a5", "g1", "modify", "2");
 713             writeGroup(ci, group8.build(), group9.build());
 714             break;
 715         case 6:
 716             GroupBuilder group10 = createTestGroup("a1", "g1", "modify", "4");
 717             GroupBuilder group11 = createTestGroup("a2", "g1", "modify", "5");
 718             writeGroup(ci, group10.build(), group11.build());
 719             break;
 720         case 7:
 721             GroupBuilder group12 = createTestGroup("a9", "g1", "modify", "6");
 722             GroupBuilder group13 = createTestGroup("a10", "g1", "modify", "7");
 723             writeGroup(ci, group12.build(), group13.build());
 724             break;
 725
 726         case 8:
 727             GroupBuilder group14 = createTestGroup("a6", "g1", "modify", "5");
 728             GroupBuilder group15 = createTestGroup("a29", "g1", "modify", "6");
 729             writeGroup(ci, group14.build(), group15.build());
 730             break;
 731
 732         }
 733
 734     }
 735
 736     private void writeGroup(CommandInterpreter ci, Group group, Group group1) {
 737         DataModification<InstanceIdentifier<?>, DataObject> modification = dataBrokerService.beginTransaction();
 738         InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class)
 739                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 740                 .child(Group.class, new GroupKey(group.getGroupId())).build();
 741         modification.putConfigurationData(nodeToInstanceId(testNode12), testNode12);
 742         modification.putConfigurationData(path1, group);
 743
 744         InstanceIdentifier<Group> path2 = InstanceIdentifier.builder(Nodes.class)
 745                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 746                 .child(Group.class, new GroupKey(group1.getGroupId())).build();
 747         modification.putConfigurationData(nodeToInstanceId(testNode12), testNode12);
 748         modification.putConfigurationData(path2, group1);
 749         Future<RpcResult<TransactionStatus>> commitFuture = modification.commit();
 750
 751         try {
 752             RpcResult<TransactionStatus> result = commitFuture.get();
 753             TransactionStatus status = result.getResult();
 754             ci.println("Status of Group Data Loaded Transaction: " + status);
 755
 756         } catch (InterruptedException e) {
 757             // TODO Auto-generated catch block
 758             e.printStackTrace();
 759         } catch (ExecutionException e) {
 760             // TODO Auto-generated catch block
 761             e.printStackTrace();
 762         }
 763     }
 764
 765     private void deleteGroup(CommandInterpreter ci, Group group, Group group1) {
 766         DataModification<InstanceIdentifier<?>, DataObject> modification = dataBrokerService.beginTransaction();
 767         InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class)
 768                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 769                 .child(Group.class, new GroupKey(group.getGroupId())).build();
 770         modification.removeOperationalData(path1);
 771         modification.removeConfigurationData(path1);
 772         InstanceIdentifier<Group> path2 = InstanceIdentifier.builder(Nodes.class)
 773                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 774                 .child(Group.class, new GroupKey(group1.getGroupId())).build();
 775         modification.removeOperationalData(path2);
 776         modification.removeConfigurationData(path2);
 777         Future<RpcResult<TransactionStatus>> commitFuture = modification.commit();
 778         try {
 779             RpcResult<TransactionStatus> result = commitFuture.get();
 780             TransactionStatus status = result.getResult();
 781             ci.println("Status of Group Data Loaded Transaction: " + status);
 782             ci.println("Status of Group Data Loaded Transaction: ");
 783
 784         } catch (InterruptedException e) {
 785             // TODO Auto-generated catch block
 786             e.printStackTrace();
 787         } catch (ExecutionException e) {
 788             // TODO Auto-generated catch block
 789             e.printStackTrace();
 790         }
 791     }
 792
 793     private GroupBuilder createTestGroup(String actiontype, String type, String mod, String iD) {
 794         // Sample data , committing to DataStore
 795
 796         String GroupType = type;
 797         String ActionType = actiontype;
 798         String Groupmod = mod;
 799
 800         long id = Long.parseLong(iD);
 801         GroupKey key = new GroupKey(new GroupId(id));
 802         GroupBuilder group = new GroupBuilder();
 803         BucketBuilder bucket = new BucketBuilder();
 804         bucket.setBucketId(new BucketId((long) 12));
 805         bucket.setKey(new BucketKey(new BucketId((long) 12)));
 806
 807         if (GroupType == null) {
 808             GroupType = "g1";
 809         }
 810         if (ActionType == null) {
 811             ActionType = "a1";
 812         }
 813
 814         switch (GroupType) {
 815         case "g1":
 816             group.setGroupType(GroupTypes.GroupSelect);
 817             break;
 818         case "g2":
 819             group.setGroupType(GroupTypes.GroupAll);
 820             break;
 821         case "g3":
 822             group.setGroupType(GroupTypes.GroupIndirect);
 823             break;
 824         case "g4":
 825             group.setGroupType(GroupTypes.GroupFf);
 826             break;
 827         }
 828
 829         switch (ActionType) {
 830         case "a1":
 831             bucket.setAction(createPopVlanAction());
 832             break;
 833         case "a2":
 834             bucket.setAction(createPushVlanAction());
 835             break;
 836         case "a3":
 837             bucket.setAction(createPushMplsAction());
 838             break;
 839         case "a4":
 840             bucket.setAction(createPopMplsAction());
 841             break;
 842         case "a5":
 843             bucket.setAction(createPopPbbAction());
 844             break;
 845         case "a6":
 846             bucket.setAction(createPushPbbAction());
 847             break;
 848         case "a7":
 849             bucket.setAction(createPushPbbAction());
 850             break;
 851         case "a8":
 852             bucket.setAction(createCopyTtlInAction());
 853             break;
 854         case "a9":
 855             bucket.setAction(createCopyTtlOutAction());
 856             break;
 857         case "a10":
 858             bucket.setAction(createDecMplsTtlAction());
 859             break;
 860         case "a14":
 861             bucket.setAction(createGroupAction());
 862             break;
 863         case "a29":
 864             bucket.setAction(createNonAppyPushVlanAction());
 865             break;
 866
 867         }
 868
 869         if (Groupmod == "add") {
 870             bucket.setWatchGroup((long) 14);
 871             bucket.setWatchPort((long) 1234);
 872             bucket.setWeight(50);
 873         } else {
 874             bucket.setWatchGroup((long) 13);
 875             bucket.setWatchPort((long) 134);
 876             bucket.setWeight(30);
 877         }
 878         group.setKey(key);
 879         // group.setInstall(false);
 880         group.setGroupId(new GroupId(id));
 881         group.setGroupName(originalGroupName);
 882         group.setBarrier(false);
 883         BucketsBuilder value = new BucketsBuilder();
 884         List<Bucket> value1 = new ArrayList<Bucket>();
 885         value1.add(bucket.build());
 886         value.setBucket(value1);
 887         group.setBuckets(value.build());
 888         testGroup = group.build();
 889         return group;
 890     }
 891
 892     private List<Action> createPopVlanAction() {
 893         PopVlanActionBuilder vlanAction = new PopVlanActionBuilder();
 894         ActionBuilder action = new ActionBuilder();
 895         action.setAction(new PopVlanActionCaseBuilder().setPopVlanAction(vlanAction.build()).build());
 896         action.setKey(new ActionKey(0));
 897         List<Action> actions = new ArrayList<Action>();
 898         actions.add(action.build());
 899         return actions;
 900     }
 901
 902     private List<Action> createPushVlanAction() {
 903         PushVlanActionBuilder vlan = new PushVlanActionBuilder();
 904         vlan.setEthernetType(new Integer(0x8100));
 905         VlanId v = new VlanId(2);
 906         vlan.setVlanId(v);
 907         ActionBuilder action = new ActionBuilder();
 908         action.setAction(new PushVlanActionCaseBuilder().setPushVlanAction(vlan.build()).build());
 909         List<Action> actions = new ArrayList<Action>();
 910         actions.add(action.build());
 911         return actions;
 912     }
 913
 914     private List<Action> createPushMplsAction() {
 915         PushMplsActionBuilder push = new PushMplsActionBuilder();
 916         push.setEthernetType(new Integer(0x8847));
 917         ActionBuilder action = new ActionBuilder();
 918         action.setAction(new PushMplsActionCaseBuilder().setPushMplsAction(push.build()).build());
 919         List<Action> actions = new ArrayList<Action>();
 920         actions.add(action.build());
 921         return actions;
 922     }
 923
 924     private List<Action> createPopMplsAction() {
 925         PopMplsActionBuilder popMplsActionBuilder = new PopMplsActionBuilder();
 926         popMplsActionBuilder.setEthernetType(0XB);
 927         ActionBuilder action = new ActionBuilder();
 928         action.setAction(new PopMplsActionCaseBuilder().setPopMplsAction(popMplsActionBuilder.build()).build());
 929         List<Action> actions = new ArrayList<Action>();
 930         actions.add(action.build());
 931         return actions;
 932     }
 933
 934     private List<Action> createPopPbbAction() {
 935         PopPbbActionBuilder popPbbActionBuilder = new PopPbbActionBuilder();
 936         ActionBuilder action = new ActionBuilder();
 937         action.setAction(new PopPbbActionCaseBuilder().setPopPbbAction(popPbbActionBuilder.build()).build());
 938         List<Action> actions = new ArrayList<Action>();
 939         actions.add(action.build());
 940         return actions;
 941     }
 942
 943     private List<Action> createPushPbbAction() {
 944         PushPbbActionBuilder pbb = new PushPbbActionBuilder();
 945         pbb.setEthernetType(new Integer(0x88E7));
 946         ActionBuilder action = new ActionBuilder();
 947         action.setAction(new PushPbbActionCaseBuilder().setPushPbbAction(pbb.build()).build());
 948         List<Action> actions = new ArrayList<Action>();
 949         actions.add(action.build());
 950         return actions;
 951     }
 952
 953     private List<Action> createCopyTtlInAction() {
 954         CopyTtlInBuilder ttlin = new CopyTtlInBuilder();
 955         ActionBuilder action = new ActionBuilder();
 956         action.setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(ttlin.build()).build());
 957         List<Action> actions = new ArrayList<Action>();
 958         actions.add(action.build());
 959         return actions;
 960     }
 961
 962     private List<Action> createCopyTtlOutAction() {
 963         CopyTtlOutBuilder ttlout = new CopyTtlOutBuilder();
 964         ActionBuilder action = new ActionBuilder();
 965         action.setAction(new CopyTtlOutCaseBuilder().setCopyTtlOut(ttlout.build()).build());
 966         List<Action> actions = new ArrayList<Action>();
 967         actions.add(action.build());
 968         return actions;
 969     }
 970
 971     private List<Action> createDecMplsTtlAction() {
 972         DecMplsTtlBuilder mpls = new DecMplsTtlBuilder();
 973         ActionBuilder action = new ActionBuilder();
 974         action.setAction(new DecMplsTtlCaseBuilder().setDecMplsTtl(mpls.build()).build());
 975         List<Action> actions = new ArrayList<Action>();
 976         actions.add(action.build());
 977         return actions;
 978     }
 979
 980     private List<Action> createGroupAction() {
 981
 982         GroupActionBuilder groupActionB = new GroupActionBuilder();
 983         groupActionB.setGroupId(1L);
 984         groupActionB.setGroup("0");
 985         ActionBuilder action = new ActionBuilder();
 986         action.setAction(new GroupActionCaseBuilder().setGroupAction(groupActionB.build()).build());
 987         action.setKey(new ActionKey(0));
 988         List<Action> actions = new ArrayList<Action>();
 989         actions.add(action.build());
 990         return actions;
 991     }
 992
 993     private static List<Action> createNonAppyPushVlanAction() {
 994
 995         List<Action> actionList = new ArrayList<Action>();
 996         ActionBuilder ab = new ActionBuilder();
 997
 998         GroupActionBuilder groupActionB = new GroupActionBuilder();
 999         groupActionB.setGroupId(1L);
1000         groupActionB.setGroup("0");
1001         ab.setAction(new GroupActionCaseBuilder().setGroupAction(groupActionB.build()).build());
1002         actionList.add(ab.build());
1003
1004         return actionList;
1005     }
1006
1007 }