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