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

   1 /*
   2  * Copyright (c) 2014, 2015 Ericsson, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowplugin.test;
  10
  11 import com.google.common.util.concurrent.CheckedFuture;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.MoreExecutors;
  15 import java.math.BigInteger;
  16 import java.util.ArrayList;
  17 import java.util.List;
  18 import org.eclipse.osgi.framework.console.CommandInterpreter;
  19 import org.eclipse.osgi.framework.console.CommandProvider;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  24 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  25 import org.opendaylight.controller.sal.binding.api.NotificationService;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.ControllerActionCaseBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlOutCaseBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecMplsTtlCaseBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecNwTtlCaseBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCaseBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopPbbActionCaseBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCaseBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCaseBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCaseBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanIdActionCaseBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.controller.action._case.ControllerActionBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlInBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.out._case.CopyTtlOutBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.mpls.ttl._case.DecMplsTtlBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtl;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtlBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropAction;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropActionBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupActionBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.pbb.action._case.PopPbbActionBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbActionBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.id.action._case.SetVlanIdActionBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.GoToTableCaseBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.MeterCaseBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.meter._case.MeterBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketKey;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.node.error.service.rev140410.NodeErrorListener;
 104 import org.opendaylight.yangtools.concepts.Registration;
 105 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 106 import org.osgi.framework.BundleContext;
 107 import org.slf4j.Logger;
 108 import org.slf4j.LoggerFactory;
 109
 110 public class OpenflowPluginBulkGroupTransactionProvider implements CommandProvider {
 111     private static final Logger LOG = LoggerFactory.getLogger(OpenflowPluginBulkGroupTransactionProvider.class);
 112     private NodeBuilder testNode;
 113     private DataBroker dataBroker;
 114     private final BundleContext ctx;
 115     private ProviderContext pc;
 116     private FlowBuilder testFlow;
 117     private final String originalFlowName = "Foo";
 118     private final NodeErrorListener nodeErrorListener = new NodeErrorListenerLoggingImpl();
 119     private Registration listener1Reg;
 120     private Registration listener2Reg;
 121     private Group testGroup;
 122     private Group testGroup2;
 123     private Node testNode12;
 124     private final String originalGroupName = "Foo";
 125     private static NotificationService notificationService;
 126
 127     public OpenflowPluginBulkGroupTransactionProvider(BundleContext ctx) {
 128         this.ctx = ctx;
 129     }
 130
 131     public void onSessionInitiated(ProviderContext session) {
 132         pc = session;
 133         notificationService = session.getSALService(NotificationService.class);
 134         listener2Reg = notificationService.registerNotificationListener(nodeErrorListener);
 135         dataBroker = session.getSALService(DataBroker.class);
 136         ctx.registerService(CommandProvider.class.getName(), this, null);
 137         createTestFlow(createTestNode(null), null, null);
 138     }
 139
 140     private NodeBuilder createTestNode(String nodeId) {
 141         if (nodeId == null) {
 142             nodeId = OpenflowpluginTestActivator.NODE_ID;
 143         }
 144         NodeRef nodeOne = createNodeRef(nodeId);
 145         NodeBuilder builder = new NodeBuilder();
 146         builder.setId(new NodeId(nodeId));
 147         builder.setKey(new NodeKey(builder.getId()));
 148         testNode = builder;
 149         return builder;
 150     }
 151
 152     private static NodeRef createNodeRef(String string) {
 153         NodeKey key = new NodeKey(new NodeId(string));
 154         InstanceIdentifier<Node> path = InstanceIdentifier.create(Nodes.class).child(Node.class, key);
 155         return new NodeRef(path);
 156     }
 157
 158     @Override
 159     public String getHelp() {
 160         return "No help";
 161     }
 162
 163     /**
 164      * @return
 165      */
 166     private static MatchBuilder createMatch1() {
 167         MatchBuilder match = new MatchBuilder();
 168         Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
 169         Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1/24");
 170         ipv4Match.setIpv4Destination(prefix);
 171         Ipv4Match i4m = ipv4Match.build();
 172         match.setLayer3Match(i4m);
 173
 174         EthernetMatchBuilder eth = new EthernetMatchBuilder();
 175         EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
 176         ethTypeBuilder.setType(new EtherType(0x0800L));
 177         eth.setEthernetType(ethTypeBuilder.build());
 178         match.setEthernetMatch(eth.build());
 179         return match;
 180     }
 181
 182     /**
 183      * @return
 184      */
 185     private static InstructionsBuilder createDecNwTtlInstructions() {
 186         DecNwTtlBuilder ta = new DecNwTtlBuilder();
 187         DecNwTtl decNwTtl = ta.build();
 188         ActionBuilder ab = new ActionBuilder();
 189         ab.setAction(new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build());
 190
 191         // Add our drop action to a list
 192         List<Action> actionList = new ArrayList<Action>();
 193         actionList.add(ab.build());
 194
 195         // Create an Apply Action
 196         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 197         aab.setAction(actionList);
 198
 199         // Wrap our Apply Action in an Instruction
 200         InstructionBuilder ib = new InstructionBuilder();
 201         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 202         ib.setKey(new InstructionKey(0));
 203         ib.setOrder(0);
 204
 205         // Put our Instruction in a list of Instructions
 206         InstructionsBuilder isb = new InstructionsBuilder();
 207         List<Instruction> instructions = new ArrayList<Instruction>();
 208         instructions.add(ib.build());
 209         isb.setInstruction(instructions);
 210         return isb;
 211     }
 212
 213     /**
 214      * @return
 215      */
 216     private static MatchBuilder createMatch2() {
 217         MatchBuilder match = new MatchBuilder();
 218         Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
 219         Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1");
 220         ipv4Match.setIpv4Source(prefix);
 221         Ipv4Match i4m = ipv4Match.build();
 222         match.setLayer3Match(i4m);
 223
 224         EthernetMatchBuilder eth = new EthernetMatchBuilder();
 225         EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
 226         ethTypeBuilder.setType(new EtherType(0x0800L));
 227         eth.setEthernetType(ethTypeBuilder.build());
 228         match.setEthernetMatch(eth.build());
 229         return match;
 230     }
 231
 232     /**
 233      * @return
 234      */
 235     private static MatchBuilder createMatch3() {
 236         MatchBuilder match = new MatchBuilder();
 237         EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
 238         EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
 239         ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
 240         ethernetMatch.setEthernetSource(ethSourceBuilder.build());
 241         match.setEthernetMatch(ethernetMatch.build());
 242
 243         return match;
 244     }
 245
 246     private static InstructionsBuilder createDropInstructions() {
 247         DropActionBuilder dab = new DropActionBuilder();
 248         DropAction dropAction = dab.build();
 249         ActionBuilder ab = new ActionBuilder();
 250         ab.setAction(new DropActionCaseBuilder().setDropAction(dropAction).build());
 251
 252         // Add our drop action to a list
 253         List<Action> actionList = new ArrayList<Action>();
 254         actionList.add(ab.build());
 255
 256         // Create an Apply Action
 257         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 258         aab.setAction(actionList);
 259
 260         // Wrap our Apply Action in an Instruction
 261         InstructionBuilder ib = new InstructionBuilder();
 262         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 263
 264         // Put our Instruction in a list of Instructions
 265         InstructionsBuilder isb = new InstructionsBuilder();
 266         List<Instruction> instructions = new ArrayList<Instruction>();
 267         instructions.add(ib.build());
 268         isb.setInstruction(instructions);
 269         return isb;
 270     }
 271
 272     private static MatchBuilder createEthernetMatch() {
 273         MatchBuilder match = new MatchBuilder();
 274
 275         byte[] mask1 = new byte[]{(byte) -1, (byte) -1, 0, 0, 0, 0};
 276         byte[] mask2 = new byte[]{(byte) -1, (byte) -1, (byte) -1, 0, 0, 0};
 277
 278         EthernetMatchBuilder ethmatch = new EthernetMatchBuilder(); // ethernettype
 279         // match
 280         EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
 281         EtherType type = new EtherType(0x0800L);
 282         ethmatch.setEthernetType(ethtype.setType(type).build());
 283
 284         EthernetDestinationBuilder ethdest = new EthernetDestinationBuilder(); // ethernet
 285         // macaddress
 286         // match
 287         MacAddress macdest = new MacAddress("ff:ff:ff:ff:ff:ff");
 288         ethdest.setAddress(macdest);
 289         // ethdest.setMask(mask1);
 290
 291         ethmatch.setEthernetDestination(ethdest.build());
 292
 293         EthernetSourceBuilder ethsrc = new EthernetSourceBuilder();
 294         MacAddress macsrc = new MacAddress("00:00:00:00:23:ae");
 295         ethsrc.setAddress(macsrc);
 296         // ethsrc.setMask(mask2);
 297
 298         ethmatch.setEthernetSource(ethsrc.build());
 299         match.setEthernetMatch(ethmatch.build());
 300         return match;
 301
 302     }
 303
 304     /**
 305      * @return
 306      */
 307     private static InstructionsBuilder createMeterInstructions() {
 308
 309         MeterBuilder aab = new MeterBuilder();
 310         aab.setMeterId(new MeterId(1L));
 311
 312         InstructionBuilder ib = new InstructionBuilder();
 313         ib.setInstruction(new MeterCaseBuilder().setMeter(aab.build()).build());
 314
 315         // Put our Instruction in a list of Instructions
 316         InstructionsBuilder isb = new InstructionsBuilder();
 317         List<Instruction> instructions = new ArrayList<Instruction>();
 318         instructions.add(ib.build());
 319         isb.setInstruction(instructions);
 320         return isb;
 321     }
 322
 323     private static InstructionsBuilder createAppyActionInstruction() {
 324
 325         List<Action> actionList = new ArrayList<Action>();
 326         ActionBuilder ab = new ActionBuilder();
 327         ControllerActionBuilder controller = new ControllerActionBuilder();
 328         controller.setMaxLength(5);
 329         ab.setAction(new ControllerActionCaseBuilder().setControllerAction(controller.build()).build());
 330         actionList.add(ab.build());
 331         // Create an Apply Action
 332         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 333         aab.setAction(actionList);
 334
 335         // Wrap our Apply Action in an Instruction
 336         InstructionBuilder ib = new InstructionBuilder();
 337         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 338
 339         // Put our Instruction in a list of Instructions
 340         InstructionsBuilder isb = new InstructionsBuilder();
 341         List<Instruction> instructions = new ArrayList<Instruction>();
 342         instructions.add(ib.build());
 343         isb.setInstruction(instructions);
 344         return isb;
 345     }
 346
 347     private static InstructionsBuilder createAppyActionInstruction7() {
 348
 349         List<Action> actionList = new ArrayList<Action>();
 350         ActionBuilder ab = new ActionBuilder();
 351
 352         SetVlanIdActionBuilder vl = new SetVlanIdActionBuilder();
 353         VlanId a = new VlanId(4012);
 354         vl.setVlanId(a);
 355         ab.setAction(new SetVlanIdActionCaseBuilder().setSetVlanIdAction(vl.build()).build());
 356         actionList.add(ab.build());
 357         // Create an Apply Action
 358         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 359         aab.setAction(actionList);
 360
 361         // Wrap our Apply Action in an Instruction
 362         InstructionBuilder ib = new InstructionBuilder();
 363         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 364
 365         // Put our Instruction in a list of Instructions
 366         InstructionsBuilder isb = new InstructionsBuilder();
 367         List<Instruction> instructions = new ArrayList<Instruction>();
 368         instructions.add(ib.build());
 369         isb.setInstruction(instructions);
 370         return isb;
 371     }
 372
 373     private static InstructionsBuilder createAppyActionInstruction21() {
 374
 375         List<Action> actionList = new ArrayList<Action>();
 376         ActionBuilder ab = new ActionBuilder();
 377
 378         PopVlanActionBuilder popVlanActionBuilder = new PopVlanActionBuilder();
 379         ab.setAction(new PopVlanActionCaseBuilder().setPopVlanAction(popVlanActionBuilder.build()).build());
 380         actionList.add(ab.build());
 381
 382         // Create an Apply Action
 383         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 384         aab.setAction(actionList);
 385
 386         // Wrap our Apply Action in an Instruction
 387         InstructionBuilder ib = new InstructionBuilder();
 388         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 389
 390         // Put our Instruction in a list of Instructions
 391         InstructionsBuilder isb = new InstructionsBuilder();
 392         List<Instruction> instructions = new ArrayList<Instruction>();
 393         instructions.add(ib.build());
 394         isb.setInstruction(instructions);
 395         return isb;
 396     }
 397
 398     private static InstructionsBuilder createAppyActionInstruction2() {
 399
 400         List<Action> actionList = new ArrayList<Action>();
 401         ActionBuilder ab = new ActionBuilder();
 402
 403         PushMplsActionBuilder push = new PushMplsActionBuilder();
 404         push.setEthernetType(0x8847);
 405         ab.setAction(new PushMplsActionCaseBuilder().setPushMplsAction(push.build()).build());
 406         actionList.add(ab.build());
 407         // Create an Apply Action
 408         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 409         aab.setAction(actionList);
 410
 411         // Wrap our Apply Action in an Instruction
 412         InstructionBuilder ib = new InstructionBuilder();
 413         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 414
 415         // Put our Instruction in a list of Instructions
 416         InstructionsBuilder isb = new InstructionsBuilder();
 417         List<Instruction> instructions = new ArrayList<Instruction>();
 418         instructions.add(ib.build());
 419         isb.setInstruction(instructions);
 420         return isb;
 421     }
 422
 423     private static InstructionsBuilder createAppyActionInstruction3() {
 424
 425         List<Action> actionList = new ArrayList<Action>();
 426         ActionBuilder ab = new ActionBuilder();
 427
 428         PushPbbActionBuilder pbb = new PushPbbActionBuilder();
 429         pbb.setEthernetType(0x88E7);
 430         ab.setAction(new PushPbbActionCaseBuilder().setPushPbbAction(pbb.build()).build());
 431         actionList.add(ab.build());
 432         // Create an Apply Action
 433         ApplyActionsBuilder aab = new ApplyActionsBuilder();
 434         aab.setAction(actionList);
 435
 436         // Wrap our Apply Action in an Instruction
 437         InstructionBuilder ib = new InstructionBuilder();
 438         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 439
 440         // Put our Instruction in a list of Instructions
 441         InstructionsBuilder isb = new InstructionsBuilder();
 442         List<Instruction> instructions = new ArrayList<Instruction>();
 443         instructions.add(ib.build());
 444         isb.setInstruction(instructions);
 445         return isb;
 446     }
 447
 448     private static InstructionsBuilder createGotoTableInstructions() {
 449
 450         GoToTableBuilder aab = new GoToTableBuilder();
 451         aab.setTableId((short) 2);
 452
 453         InstructionBuilder ib = new InstructionBuilder();
 454         ib.setInstruction(new GoToTableCaseBuilder().setGoToTable(aab.build()).build());
 455
 456         // Put our Instruction in a list of Instructions
 457         InstructionsBuilder isb = new InstructionsBuilder();
 458         List<Instruction> instructions = new ArrayList<Instruction>();
 459         instructions.add(ib.build());
 460         isb.setInstruction(instructions);
 461         return isb;
 462     }
 463
 464     private FlowBuilder createTestFlow(NodeBuilder nodeBuilder, String flowTypeArg, String tableId) {
 465
 466         FlowBuilder flow = new FlowBuilder();
 467         long id = 123;
 468
 469         String flowType = flowTypeArg;
 470         if (flowType == null) {
 471             flowType = "f1";
 472         }
 473
 474         switch (flowType) {
 475             case "f1":
 476                 id += 1;
 477                 flow.setMatch(createMatch1().build());
 478                 flow.setInstructions(createDecNwTtlInstructions().build());
 479                 break;
 480             case "f2":
 481                 id += 2;
 482                 flow.setMatch(createMatch2().build());
 483                 flow.setInstructions(createDropInstructions().build());
 484                 break;
 485             case "f3":
 486                 id += 3;
 487                 flow.setMatch(createMatch3().build());
 488                 flow.setInstructions(createDropInstructions().build());
 489                 break;
 490             case "f4":
 491                 id += 4;
 492                 flow.setMatch(createEthernetMatch().build());
 493                 flow.setInstructions(createDropInstructions().build());
 494                 break;
 495             case "f82":
 496                 id += 1;
 497                 flow.setMatch(createMatch1().build());
 498                 flow.setInstructions(createDropInstructions().build());
 499                 break;
 500             case "f5":
 501                 id += 5;
 502                 flow.setMatch(createMatch1().build());
 503                 flow.setInstructions(createAppyActionInstruction().build());
 504                 break;
 505             case "f6":
 506                 id += 6;
 507                 flow.setMatch(createMatch1().build());
 508                 flow.setInstructions(createGotoTableInstructions().build());
 509                 break;
 510             case "f7":
 511                 id += 7;
 512                 flow.setMatch(createMatch1().build());
 513                 flow.setInstructions(createMeterInstructions().build());
 514                 break;
 515             case "f8":
 516                 id += 8;
 517                 flow.setMatch(createMatch1().build());
 518                 flow.setInstructions(createAppyActionInstruction7().build());
 519                 break;
 520             case "f9":
 521                 id += 9;
 522                 flow.setMatch(createMatch1().build());
 523                 flow.setInstructions(createAppyActionInstruction2().build());
 524                 break;
 525             case "f10":
 526                 id += 10;
 527                 flow.setMatch(createMatch1().build());
 528                 flow.setInstructions(createAppyActionInstruction3().build());
 529                 break;
 530             case "f14":
 531                 id += 14;
 532                 flow.setMatch(createMatch1().build());
 533                 flow.setInstructions(createAppyActionInstruction7().build());
 534                 break;
 535             case "f29":
 536                 id += 29;
 537                 flow.setMatch(createMatch1().build());
 538                 flow.setInstructions(createAppyActionInstruction21().build());
 539                 break;
 540
 541             default:
 542                 LOG.warn("flow type not understood: {}", flowType);
 543         }
 544
 545         FlowKey key = new FlowKey(new FlowId(Long.toString(id)));
 546         if (null == flow.isBarrier()) {
 547             flow.setBarrier(Boolean.FALSE);
 548         }
 549         // flow.setBufferId(12L);
 550         BigInteger value = BigInteger.valueOf(10);
 551         BigInteger outputPort = BigInteger.valueOf(4294967295L);
 552         flow.setCookie(new FlowCookie(value));
 553         flow.setCookieMask(new FlowCookie(value));
 554         flow.setHardTimeout(0);
 555         flow.setIdleTimeout(0);
 556         flow.setInstallHw(false);
 557         flow.setStrict(false);
 558         flow.setContainerName(null);
 559         flow.setFlags(new FlowModFlags(false, false, false, false, true));
 560         flow.setId(new FlowId("12"));
 561         flow.setTableId(getTableId(tableId));
 562         flow.setOutGroup(4294967295L);
 563         // set outport to OFPP_NONE (65535) to disable remove restriction for
 564         // flow
 565         flow.setOutPort(outputPort);
 566
 567         flow.setKey(key);
 568         flow.setPriority(2);
 569         flow.setFlowName(originalFlowName + "X" + flowType);
 570         testFlow = flow;
 571         return flow;
 572     }
 573
 574     private short getTableId(String tableId) {
 575         short table = 2;
 576         try {
 577             table = Short.parseShort(tableId);
 578         } catch (Exception ex) {
 579             // ignore exception and continue with default value
 580         }
 581
 582         return table;
 583
 584     }
 585
 586     public void _addGroups(CommandInterpreter ci) {
 587         String nref = ci.nextArgument();
 588
 589         if (nref == null) {
 590             ci.println("test node added");
 591             createTestNode();
 592         } else {
 593             ci.println("User node added" + nref);
 594             createUserNode(nref);
 595         }
 596         Integer count = Integer.parseInt(ci.nextArgument());
 597         switch (count) {
 598             case 1:
 599                 GroupBuilder group = createTestGroup("a7", "g1", "add", "1");
 600                 GroupBuilder group1 = createTestGroup("a3", "g1", "add", "2");
 601                 writeGroup(ci, group.build(), group1.build());
 602                 break;
 603             case 2:
 604                 GroupBuilder group2 = createTestGroup("a4", "g1", "add", "4");
 605                 GroupBuilder group3 = createTestGroup("a5", "g1", "add", "5");
 606                 writeGroup(ci, group2.build(), group3.build());
 607                 break;
 608             case 3:
 609                 GroupBuilder group4 = createTestGroup("a6", "g1", "add", "6");
 610                 GroupBuilder group5 = createTestGroup("a7", "g1", "add", "7");
 611                 writeGroup(ci, group4.build(), group5.build());
 612                 break;
 613             case 4:
 614                 // -ve
 615                 GroupBuilder group6 = createTestGroup("a14", "g1", "add", "5");
 616                 GroupBuilder group7 = createTestGroup("a3", "g1", "add", "6");
 617                 writeGroup(ci, group6.build(), group7.build());
 618                 break;
 619
 620         }
 621
 622     }
 623
 624     private void createUserNode(String nodeRef) {
 625         NodeRef nodeOne = createNodeRef(nodeRef);
 626         NodeBuilder builder = new NodeBuilder();
 627         builder.setId(new NodeId(nodeRef));
 628         builder.setKey(new NodeKey(builder.getId()));
 629         testNode12 = builder.build();
 630     }
 631
 632     public void _modifyGroups(CommandInterpreter ci) {
 633         String nref = ci.nextArgument();
 634
 635         if (nref == null) {
 636             ci.println("test node added");
 637             createTestNode();
 638         } else {
 639             ci.println("User node added" + nref);
 640             createUserNode(nref);
 641         }
 642         Integer count = Integer.parseInt(ci.nextArgument());
 643         switch (count) {
 644             case 1:
 645                 GroupBuilder group = createTestGroup("a4", "g1", "modify", "1");
 646                 GroupBuilder group1 = createTestGroup("a5", "g1", "modify", "2");
 647                 writeGroup(ci, group.build(), group1.build());
 648                 break;
 649             case 2:
 650                 GroupBuilder group2 = createTestGroup("a1", "g1", "modify", "4");
 651                 GroupBuilder group3 = createTestGroup("a2", "g1", "modify", "5");
 652                 writeGroup(ci, group2.build(), group3.build());
 653                 break;
 654             case 3:
 655                 GroupBuilder group4 = createTestGroup("a9", "g1", "modify", "6");
 656                 GroupBuilder group5 = createTestGroup("a10", "g1", "modify", "7");
 657                 writeGroup(ci, group4.build(), group5.build());
 658                 break;
 659
 660             case 4:
 661                 GroupBuilder group6 = createTestGroup("a6", "g1", "modify", "5");
 662                 GroupBuilder group7 = createTestGroup("a29", "g1", "modify", "6");
 663                 writeGroup(ci, group6.build(), group7.build());
 664                 break;
 665         }
 666     }
 667
 668     private InstanceIdentifier<Node> nodeToInstanceId(Node node) {
 669         return InstanceIdentifier.create(Nodes.class).child(Node.class, node.getKey());
 670     }
 671
 672     private void createTestNode() {
 673         NodeRef nodeOne = createNodeRef(OpenflowpluginTestActivator.NODE_ID);
 674         NodeBuilder builder = new NodeBuilder();
 675         builder.setId(new NodeId(OpenflowpluginTestActivator.NODE_ID));
 676         builder.setKey(new NodeKey(builder.getId()));
 677         testNode12 = builder.build();
 678     }
 679
 680     public void _removeGroups(CommandInterpreter ci) {
 681         String nref = ci.nextArgument();
 682
 683         if (nref == null) {
 684             ci.println("test node added");
 685             createTestNode();
 686         } else {
 687             ci.println("User node added" + nref);
 688             createUserNode(nref);
 689         }
 690
 691         Integer count = Integer.parseInt(ci.nextArgument());
 692         switch (count) {
 693             case 1:
 694                 GroupBuilder group = createTestGroup("a2", "g1", "remove", "1");
 695                 GroupBuilder group1 = createTestGroup("a3", "g1", "remove", "2");
 696                 deleteGroup(ci, group.build(), group1.build());
 697                 break;
 698             case 2:
 699                 GroupBuilder group2 = createTestGroup("a4", "g1", "remove", "4");
 700                 GroupBuilder group3 = createTestGroup("a5", "g1", "remove", "5");
 701                 deleteGroup(ci, group2.build(), group3.build());
 702                 break;
 703             case 3:
 704                 GroupBuilder group4 = createTestGroup("a6", "g1", "remove", "6");
 705                 GroupBuilder group5 = createTestGroup("a7", "g1", "remove", "7");
 706                 deleteGroup(ci, group4.build(), group5.build());
 707                 break;
 708             case 4:
 709                 GroupBuilder group6 = createTestGroup("a14", "g1", "remove", "5");
 710                 GroupBuilder group7 = createTestGroup("a3", "g1", "remove", "6");
 711                 deleteGroup(ci, group6.build(), group7.build());
 712                 break;
 713             case 5:
 714                 GroupBuilder group8 = createTestGroup("a4", "g1", "modify", "1");
 715                 GroupBuilder group9 = createTestGroup("a5", "g1", "modify", "2");
 716                 writeGroup(ci, group8.build(), group9.build());
 717                 break;
 718             case 6:
 719                 GroupBuilder group10 = createTestGroup("a1", "g1", "modify", "4");
 720                 GroupBuilder group11 = createTestGroup("a2", "g1", "modify", "5");
 721                 writeGroup(ci, group10.build(), group11.build());
 722                 break;
 723             case 7:
 724                 GroupBuilder group12 = createTestGroup("a9", "g1", "modify", "6");
 725                 GroupBuilder group13 = createTestGroup("a10", "g1", "modify", "7");
 726                 writeGroup(ci, group12.build(), group13.build());
 727                 break;
 728
 729             case 8:
 730                 GroupBuilder group14 = createTestGroup("a6", "g1", "modify", "5");
 731                 GroupBuilder group15 = createTestGroup("a29", "g1", "modify", "6");
 732                 writeGroup(ci, group14.build(), group15.build());
 733                 break;
 734
 735         }
 736
 737     }
 738
 739     private void writeGroup(final CommandInterpreter ci, Group group, Group group1) {
 740         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 741
 742         InstanceIdentifier<Group> path1 = InstanceIdentifier.create(Nodes.class)
 743                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 744                 .child(Group.class, new GroupKey(group.getGroupId()));
 745         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode12), testNode12, true);
 746         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, group, true);
 747
 748         InstanceIdentifier<Group> path2 = InstanceIdentifier.create(Nodes.class)
 749                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 750                 .child(Group.class, new GroupKey(group1.getGroupId()));
 751         modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode12), testNode12, true);
 752         modification.merge(LogicalDatastoreType.CONFIGURATION, path2, group1, true);
 753         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 754         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 755             @Override
 756             public void onSuccess(Void aVoid) {
 757                 ci.println("Status of Group Data Loaded Transaction: success.");
 758             }
 759
 760             @Override
 761             public void onFailure(Throwable throwable) {
 762                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 763             }
 764         }, MoreExecutors.directExecutor());
 765     }
 766
 767     private void deleteGroup(final CommandInterpreter ci, Group group, Group group1) {
 768         ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
 769         InstanceIdentifier<Group> path1 = InstanceIdentifier.create(Nodes.class)
 770                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 771                 .child(Group.class, new GroupKey(group.getGroupId()));
 772         modification.delete(LogicalDatastoreType.OPERATIONAL, path1);
 773         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
 774         InstanceIdentifier<Group> path2 = InstanceIdentifier.create(Nodes.class)
 775                 .child(Node.class, testNode12.getKey()).augmentation(FlowCapableNode.class)
 776                 .child(Group.class, new GroupKey(group1.getGroupId()));
 777         modification.delete(LogicalDatastoreType.OPERATIONAL, path2);
 778         modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
 779         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
 780         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
 781             @Override
 782             public void onSuccess(Void aVoid) {
 783                 ci.println("Status of Group Data Loaded Transaction: success.");
 784             }
 785
 786             @Override
 787             public void onFailure(Throwable throwable) {
 788                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
 789             }
 790         }, MoreExecutors.directExecutor());
 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(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(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(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 }