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