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

   1 /*
   2  * Copyright (c) 2013, 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.FutureCallback;
  12 import com.google.common.util.concurrent.Futures;
  13 import com.google.common.util.concurrent.ListenableFuture;
  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 java.util.concurrent.ExecutorService;
  19 import java.util.concurrent.Executors;
  20 import java.util.concurrent.TimeUnit;
  21 import org.eclipse.osgi.framework.console.CommandInterpreter;
  22 import org.eclipse.osgi.framework.console.CommandProvider;
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  27 import org.opendaylight.controller.sal.binding.api.NotificationService;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6FlowLabel;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.VlanCfi;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.ControllerActionCaseBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlOutCaseBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecMplsTtlCaseBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DecNwTtlCaseBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCaseBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.FloodActionCaseBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.FloodAllActionCaseBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.HwPathActionCaseBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.LoopbackActionCaseBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopPbbActionCaseBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCaseBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCaseBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCaseBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlDstActionCaseBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlSrcActionCaseBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlTypeActionCaseBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCaseBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNextHopActionCaseBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwDstActionCaseBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwSrcActionCaseBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTosActionCaseBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTtlActionCaseBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetQueueActionCaseBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetTpDstActionCaseBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetTpSrcActionCaseBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanCfiActionCaseBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanIdActionCaseBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanPcpActionCaseBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.StripVlanActionCaseBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SwPathActionCaseBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.controller.action._case.ControllerActionBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlInBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.out._case.CopyTtlOutBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.mpls.ttl._case.DecMplsTtlBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtl;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.dec.nw.ttl._case.DecNwTtlBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropAction;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropActionBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.flood.action._case.FloodActionBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.flood.all.action._case.FloodAllActionBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupActionBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.hw.path.action._case.HwPathActionBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.loopback.action._case.LoopbackActionBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.pbb.action._case.PopPbbActionBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbActionBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.dst.action._case.SetDlDstActionBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.src.action._case.SetDlSrcActionBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.type.action._case.SetDlTypeActionBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetFieldBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlActionBuilder;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.next.hop.action._case.SetNextHopActionBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.dst.action._case.SetNwDstActionBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.src.action._case.SetNwSrcActionBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.tos.action._case.SetNwTosActionBuilder;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.ttl.action._case.SetNwTtlActionBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.queue.action._case.SetQueueActionBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.tp.dst.action._case.SetTpDstActionBuilder;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.tp.src.action._case.SetTpSrcActionBuilder;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.cfi.action._case.SetVlanCfiActionBuilder;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.id.action._case.SetVlanIdActionBuilder;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.pcp.action._case.SetVlanPcpActionBuilder;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.strip.vlan.action._case.StripVlanActionBuilder;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.sw.path.action._case.SwPathActionBuilder;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
 112 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
 113 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4Builder;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
 118 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
 119 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
 121 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
 122 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
 123 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
 124 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.OutputPortValues;
 125 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
 126 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
 127 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
 128 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.GoToTableCaseBuilder;
 129 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.MeterCaseBuilder;
 130 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCaseBuilder;
 131 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
 132 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder;
 133 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.meter._case.MeterBuilder;
 134 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadataBuilder;
 135 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
 136 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
 137 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
 138 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 139 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 140 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
 141 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 142 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
 143 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
 144 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
 145 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
 146 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanPcp;
 147 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
 148 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpSourceHardwareAddressBuilder;
 149 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpTargetHardwareAddressBuilder;
 150 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
 151 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
 152 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
 153 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ipv6.match.fields.Ipv6ExtHeaderBuilder;
 154 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ipv6.match.fields.Ipv6LabelBuilder;
 155 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
 156 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv4MatchBuilder;
 157 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv6MatchBuilder;
 158 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
 159 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.MetadataBuilder;
 160 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFieldsBuilder;
 161 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TcpFlagsMatchBuilder;
 162 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TunnelBuilder;
 163 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatchBuilder;
 164 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatchBuilder;
 165 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
 166 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
 167 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchBuilder;
 168 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.TunnelIpv4MatchBuilder;
 169 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.SctpMatchBuilder;
 170 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
 171 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatchBuilder;
 172 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.protocol.match.fields.PbbBuilder;
 173 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
 174 import org.opendaylight.yang.gen.v1.urn.opendaylight.node.error.service.rev140410.NodeErrorListener;
 175 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 176 import org.osgi.framework.BundleContext;
 177 import org.slf4j.Logger;
 178 import org.slf4j.LoggerFactory;
 179
 180 @SuppressWarnings("checkstyle:MethodName")
 181 public class OpenflowpluginTestCommandProvider implements CommandProvider {
 182
 183     private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestCommandProvider.class);
 184
 185     private DataBroker dataBroker;
 186     private final BundleContext ctx;
 187     private static final String ORIGINAL_FLOW_NAME = "Foo";
 188     private static final String UPDATED_FLOW_NAME = "Bar";
 189     private static final String IPV4_PREFIX = "10.0.0.1/24";
 190     private static final String DEST_MAC_ADDRESS = "ff:ff:ff:ff:ff:ff";
 191     private static final String SRC_MAC_ADDRESS = "00:00:00:00:23:ae";
 192     private final SalFlowListener flowEventListener = new FlowEventListenerLoggingImpl();
 193     private final NodeErrorListener nodeErrorListener = new NodeErrorListenerLoggingImpl();
 194     private NotificationService notificationService;
 195
 196     public OpenflowpluginTestCommandProvider(final BundleContext ctx) {
 197         this.ctx = ctx;
 198     }
 199
 200     public void onSessionInitiated(final ProviderContext session) {
 201         notificationService = session.getSALService(NotificationService.class);
 202         // For switch events
 203         notificationService.registerNotificationListener(flowEventListener);
 204         notificationService.registerNotificationListener(nodeErrorListener);
 205         dataBroker = session.getSALService(DataBroker.class);
 206         ctx.registerService(CommandProvider.class.getName(), this, null);
 207         createTestFlow(createTestNode(null), null, null);
 208     }
 209
 210     private NodeBuilder createTestNode(final String nodeId) {
 211         String localNodeId;
 212
 213         if (nodeId == null) {
 214             localNodeId = OpenflowpluginTestActivator.NODE_ID;
 215         } else {
 216             localNodeId = nodeId;
 217         }
 218
 219         final NodeBuilder builder = new NodeBuilder();
 220         builder.setId(new NodeId(localNodeId));
 221         builder.setKey(new NodeKey(builder.getId()));
 222         return builder;
 223     }
 224
 225     private InstanceIdentifier<Node> nodeBuilderToInstanceId(final NodeBuilder node) {
 226         return InstanceIdentifier.create(Nodes.class).child(Node.class, node.getKey());
 227     }
 228
 229     private FlowBuilder createTestFlow(final NodeBuilder nodeBuilder, final String flowTypeArg, final String tableId) {
 230         final long TEST_ID = 123;
 231
 232         final FlowBuilder flow = new FlowBuilder();
 233         long id = TEST_ID;
 234
 235         String flowType = flowTypeArg;
 236         if (flowType == null) {
 237             flowType = "f1";
 238         }
 239
 240         flow.setPriority(2);
 241
 242         switch (flowType) {
 243             case "f1":
 244                 id += 1;
 245                 flow.setMatch(createMatch1().build());
 246                 flow.setInstructions(createDecNwTtlInstructions().build());
 247                 break;
 248             case "f2":
 249                 id += 2;
 250                 flow.setMatch(createMatch2().build());
 251                 flow.setInstructions(createDropInstructions().build());
 252                 break;
 253             case "f3":
 254                 id += 3;
 255                 flow.setMatch(createMatch3().build());
 256                 flow.setInstructions(createDropInstructions().build());
 257                 break;
 258             case "f4":
 259                 id += 4;
 260                 flow.setMatch(createEthernetMatch().build());
 261                 flow.setInstructions(createDropInstructions().build());
 262                 break;
 263             case "f5":
 264                 id += 5;
 265                 flow.setMatch(createMatch1().build());
 266                 flow.setInstructions(createAppyActionInstruction().build());
 267                 break;
 268             case "f6":
 269                 id += 6;
 270                 flow.setMatch(createMatch1().build());
 271                 flow.setInstructions(createGotoTableInstructions().build());
 272                 break;
 273             case "f7":
 274                 id += 7;
 275                 flow.setMatch(createMatch1().build());
 276                 flow.setInstructions(createMeterInstructions().build());
 277                 break;
 278             case "f8":
 279                 id += 8;
 280                 flow.setMatch(createMatch1().build());
 281                 flow.setInstructions(createAppyActionInstruction1().build());
 282                 break;
 283             case "f9":
 284                 id += 9;
 285                 flow.setMatch(createMatch1().build());
 286                 flow.setInstructions(createAppyActionInstruction2().build());
 287                 break;
 288             case "f10":
 289                 id += 10;
 290                 flow.setMatch(createMatch1().build());
 291                 flow.setInstructions(createAppyActionInstruction3().build());
 292                 break;
 293             case "f11":
 294                 id += 11;
 295                 flow.setMatch(createMatch1().build());
 296                 flow.setInstructions(createAppyActionInstruction4().build());
 297                 break;
 298             case "f12":
 299                 id += 12;
 300                 flow.setMatch(createMatch1().build());
 301                 flow.setInstructions(createAppyActionInstruction5().build());
 302                 break;
 303             case "f13":
 304                 id += 13;
 305                 flow.setMatch(createMatch1().build());
 306                 flow.setInstructions(createAppyActionInstruction6().build());
 307                 break;
 308             case "f14":
 309                 id += 14;
 310                 flow.setMatch(createMatch1().build());
 311                 flow.setInstructions(createAppyActionInstruction7().build());
 312                 break;
 313             case "f15":
 314                 id += 15;
 315                 flow.setMatch(createMatch1().build());
 316                 flow.setInstructions(createAppyActionInstruction8().build());
 317                 break;
 318             case "f16":
 319                 id += 16;
 320                 flow.setMatch(createMatch1().build());
 321                 flow.setInstructions(createAppyActionInstruction9().build());
 322                 break;
 323             case "f17":
 324                 id += 17;
 325                 flow.setMatch(createMatch1().build());
 326                 flow.setInstructions(createAppyActionInstruction10().build());
 327                 break;
 328             case "f18":
 329                 id += 18;
 330                 flow.setMatch(createMatch1().build());
 331                 flow.setInstructions(createAppyActionInstruction11().build());
 332                 break;
 333             case "f19":
 334                 id += 19;
 335                 flow.setMatch(createMatch1().build());
 336                 flow.setInstructions(createAppyActionInstruction12().build());
 337                 break;
 338             case "f20":
 339                 id += 20;
 340                 flow.setMatch(createMatch1().build());
 341                 flow.setInstructions(createAppyActionInstruction13().build());
 342                 break;
 343             case "f21":
 344                 id += 21;
 345                 flow.setMatch(createMatch1().build());
 346                 flow.setInstructions(createAppyActionInstruction14().build());
 347                 break;
 348             case "f22":
 349                 id += 22;
 350                 flow.setMatch(createMatch1().build());
 351                 flow.setInstructions(createAppyActionInstruction15().build());
 352                 break;
 353             case "f23":
 354                 id += 23;
 355                 // f23 can be used as test-case for generating error notification
 356                 // if the particular group is not configured - tested
 357                 flow.setMatch(createMatch1().build());
 358                 flow.setInstructions(createAppyActionInstruction16().build());
 359                 break;
 360             case "f24":
 361                 id += 24;
 362                 flow.setMatch(createMatch1().build());
 363                 flow.setInstructions(createAppyActionInstruction17().build());
 364                 break;
 365             case "f25":
 366                 id += 25;
 367                 flow.setMatch(createMatch1().build());
 368                 flow.setInstructions(createAppyActionInstruction18().build());
 369                 break;
 370             case "f26":
 371                 id += 26;
 372                 flow.setMatch(createMatch1().build());
 373                 flow.setInstructions(createAppyActionInstruction19().build());
 374                 break;
 375             case "f27":
 376                 id += 27;
 377                 flow.setMatch(createMatch1().build());
 378                 flow.setInstructions(createMetadataInstructions().build());
 379                 break;
 380             case "f28":
 381                 id += 28;
 382                 flow.setMatch(createMatch1().build());
 383                 flow.setInstructions(createAppyActionInstruction20().build());
 384                 break;
 385             case "f29":
 386                 id += 29;
 387                 flow.setMatch(createMatch1().build());
 388                 flow.setInstructions(createAppyActionInstruction21().build());
 389                 break;
 390             case "f30":
 391                 id += 30;
 392                 flow.setMatch(createMatch1().build());
 393                 flow.setInstructions(createAppyActionInstruction22().build());
 394                 break;
 395             case "f31":
 396                 id += 31;
 397                 flow.setMatch(createMatch1().build());
 398                 flow.setInstructions(createAppyActionInstruction23(nodeBuilder.getId()).build());
 399                 break;
 400             case "f32":
 401                 id += 32;
 402                 flow.setMatch(createMatch1().build());
 403                 flow.setInstructions(createAppyActionInstruction24().build());
 404                 break;
 405             case "f33":
 406                 id += 33;
 407                 flow.setMatch(createMatch1().build());
 408                 flow.setInstructions(createAppyActionInstruction25().build());
 409                 break;
 410             case "f34":
 411                 id += 34;
 412                 flow.setMatch(createMatch1().build());
 413                 flow.setInstructions(createAppyActionInstruction26().build());
 414                 break;
 415             case "f35":
 416                 id += 35;
 417                 flow.setMatch(createMatch1().build());
 418                 flow.setInstructions(createAppyActionInstruction27().build());
 419                 break;
 420             case "f36":
 421                 id += 36;
 422                 flow.setMatch(createMatch1().build());
 423                 flow.setInstructions(createAppyActionInstruction28().build());
 424                 break;
 425             case "f37":
 426                 id += 37;
 427                 flow.setMatch(createMatch1().build());
 428                 flow.setInstructions(createAppyActionInstruction29().build());
 429                 break;
 430             case "f38":
 431                 id += 38;
 432                 flow.setMatch(createMatch1().build());
 433                 flow.setInstructions(createAppyActionInstruction30().build());
 434                 break;
 435             case "f39":
 436                 id += 39;
 437                 flow.setMatch(createMatch1().build());
 438                 flow.setInstructions(createAppyActionInstruction31().build());
 439                 break;
 440             case "f40":
 441                 id += 40;
 442                 flow.setMatch(createMatch1().build());
 443                 flow.setInstructions(createAppyActionInstruction32().build());
 444                 break;
 445             case "f41":
 446                 id += 41;
 447                 flow.setMatch(createMatch1().build());
 448                 flow.setInstructions(createAppyActionInstruction33().build());
 449                 break;
 450             case "f42":
 451                 id += 42;
 452                 flow.setMatch(createMatch1().build());
 453                 flow.setInstructions(createAppyActionInstruction34().build());
 454                 break;
 455             case "f43":
 456                 id += 43;
 457                 flow.setMatch(createICMPv6Match().build());
 458                 flow.setInstructions(createDecNwTtlInstructions().build());
 459                 break;
 460             case "f44":
 461                 id += 44;
 462                 flow.setMatch(createInphyportMatch(nodeBuilder.getId()).build());
 463                 flow.setInstructions(createDropInstructions().build());
 464                 break;
 465             case "f45":
 466                 id += 45;
 467                 flow.setMatch(createMetadataMatch().build());
 468                 flow.setInstructions(createDropInstructions().build());
 469                 break;
 470             case "f46":
 471                 id += 46;
 472                 flow.setMatch(createL3IPv6Match().build());
 473                 flow.setInstructions(createDecNwTtlInstructions().build());
 474                 break;
 475             case "f47":
 476                 id += 47;
 477                 flow.setMatch(createL4SCTPMatch().build());
 478                 flow.setInstructions(createAppyActionInstruction().build());
 479                 break;
 480             case "f48":
 481                 id += 48;
 482                 flow.setMatch(createTunnelIDMatch().build());
 483                 flow.setInstructions(createGotoTableInstructions().build());
 484                 break;
 485             case "f49":
 486                 id += 49;
 487                 flow.setMatch(createVlanMatch().build());
 488                 flow.setInstructions(createMeterInstructions().build());
 489                 break;
 490             case "f50":
 491                 id += 50;
 492                 flow.setMatch(createPbbMatch().build());
 493                 flow.setInstructions(createMeterInstructions().build());
 494                 break;
 495             case "f51":
 496                 id += 51;
 497                 flow.setMatch(createVlanMatch().build());
 498                 flow.setInstructions(createDropInstructions().build());
 499                 break;
 500             case "f52":
 501                 id += 52;
 502                 flow.setMatch(createL4TCPMatch().build());
 503                 flow.setInstructions(createDropInstructions().build());
 504                 break;
 505
 506             case "f53":
 507                 id += 53;
 508                 flow.setMatch(createL4UDPMatch().build());
 509                 flow.setInstructions(createDropInstructions().build());
 510                 break;
 511             case "f54":
 512                 id += 54;
 513                 flow.setMatch(new MatchBuilder().build());
 514                 flow.setInstructions(createSentToControllerInstructions().build());
 515                 flow.setPriority(0);
 516                 break;
 517             case "f55":
 518                 id += 55;
 519                 flow.setMatch(createToSMatch().build());
 520                 flow.setInstructions(createDropInstructions().build());
 521                 break;
 522             case "f56":
 523                 id += 56;
 524                 flow.setMatch(createToSMatch().build());
 525                 flow.setInstructions(createOutputInstructions("INPORT", 10).build());
 526                 break;
 527             case "f57":
 528                 id += 57;
 529                 flow.setMatch(createToSMatch().build());
 530                 flow.setInstructions(createOutputInstructions("FLOOD", 20).build());
 531                 break;
 532             case "f58":
 533                 id += 58;
 534                 flow.setMatch(createToSMatch().build());
 535                 flow.setInstructions(createOutputInstructions("ALL", 30).build());
 536                 break;
 537             case "f59":
 538                 id += 59;
 539                 flow.setMatch(createToSMatch().build());
 540                 flow.setInstructions(createOutputInstructions("NORMAL", 40).build());
 541                 break;
 542             case "f60":
 543                 id += 60;
 544                 flow.setMatch(createToSMatch().build());
 545                 flow.setInstructions(createOutputInstructions("LOCAL", 50).build());
 546                 break;
 547             case "f61":
 548                 id += 61;
 549                 flow.setMatch(createToSMatch().build());
 550                 flow.setInstructions(createOutputInstructions("TABLE", 60).build());
 551                 break;
 552             case "f62":
 553                 id += 62;
 554                 flow.setMatch(createToSMatch().build());
 555                 flow.setInstructions(createOutputInstructions("NONE", 70).build());
 556                 break;
 557             case "f63":
 558                 id += 63;
 559                 flow.setMatch(createToSMatch().build());
 560                 flow.setInstructions(createStripVlanInstructions().build());
 561                 flow.setBarrier(Boolean.TRUE);
 562                 break;
 563             case "f64":
 564                 id += 64;
 565                 flow.setMatch(createMatch1().build());
 566                 flow.setInstructions(createAppyActionInstruction35().build());
 567                 break;
 568             case "f65":
 569                 id += 65;
 570                 flow.setMatch(createMatch1().build());
 571                 flow.setInstructions(createAppyActionInstruction36().build());
 572                 break;
 573             case "f66":
 574                 id += 66;
 575                 flow.setMatch(createMatch1().build());
 576                 flow.setInstructions(createAppyActionInstruction37().build());
 577                 break;
 578             case "f67":
 579                 id += 67;
 580                 flow.setMatch(createMatch1().build());
 581                 flow.setInstructions(createAppyActionInstruction38().build());
 582                 break;
 583             case "f68":
 584                 id += 68;
 585                 flow.setMatch(createL4TCPMatch().build());
 586                 flow.setInstructions(createAppyActionInstruction39().build());
 587                 break;
 588             case "f69":
 589                 id += 69;
 590                 flow.setMatch(createL4UDPMatch().build());
 591                 flow.setInstructions(createAppyActionInstruction40().build());
 592                 break;
 593             case "f70":
 594                 id += 70;
 595                 flow.setMatch(createL4SCTPMatch().build());
 596                 flow.setInstructions(createAppyActionInstruction41().build());
 597                 break;
 598             case "f71":
 599                 id += 71;
 600                 flow.setMatch(createICMPv4Match().build());
 601                 flow.setInstructions(createAppyActionInstruction42().build());
 602                 break;
 603             case "f72":
 604                 id += 72;
 605                 flow.setMatch(createArpMatch().build());
 606                 flow.setInstructions(createAppyActionInstruction43().build());
 607                 break;
 608             case "f73":
 609                 id += 73;
 610                 flow.setMatch(createL3IPv6Match().build());
 611                 flow.setInstructions(createAppyActionInstruction44().build());
 612                 break;
 613             case "f74":
 614                 id += 74;
 615                 flow.setMatch(createICMPv6Match().build());
 616                 flow.setInstructions(createAppyActionInstruction45().build());
 617                 break;
 618             case "f75":
 619                 id += 75;
 620                 flow.setMatch(createMplsMatch().build());
 621                 flow.setInstructions(createAppyActionInstruction46().build());
 622                 break;
 623             case "f76":
 624                 id += 76;
 625                 flow.setMatch(createPbbMatch().build());
 626                 flow.setInstructions(createAppyActionInstruction47().build());
 627                 break;
 628             case "f77":
 629                 id += 77;
 630                 flow.setMatch(createTunnelIDMatch().build());
 631                 flow.setInstructions(createAppyActionInstruction48().build());
 632                 break;
 633             case "f78":
 634                 id += 78;
 635                 flow.setMatch(createMatch33().build());
 636                 flow.setInstructions(createDropInstructions().build());
 637                 break;
 638             case "f79":
 639                 id += 79;
 640                 flow.setMatch(createICMPv6Match1().build());
 641                 flow.setInstructions(createDecNwTtlInstructions().build());
 642                 break;
 643             case "f80":
 644                 id += 80;
 645                 flow.setMatch(createVlanMatch().build());
 646                 flow.setInstructions(createAppyActionInstruction88().build());
 647                 break;
 648             case "f81":
 649                 id += 81;
 650                 flow.setMatch(createLLDPMatch().build());
 651                 flow.setInstructions(createSentToControllerInstructions().build());
 652                 break;
 653             case "f82":
 654                 id += 82;
 655                 flow.setMatch(createToSMatch().build());
 656                 flow.setInstructions(createOutputInstructions().build());
 657                 break;
 658             case "f83":
 659                 // Test TCP_Flag Match
 660                 id += 83;
 661                 flow.setMatch(createTcpFlagMatch().build());
 662                 flow.setInstructions(createDropInstructions().build());
 663                 break;
 664             case "f84":
 665                 id += 84;
 666                 // match vlan=10,dl_vlan_pcp=3
 667                 flow.setMatch(createVlanMatch().build());
 668                 // vlan_pcp=4
 669                 flow.setInstructions(createAppyActionInstruction88().build());
 670                 break;
 671             case "f85":
 672                 // Test Tunnel IPv4 Src (e.g. set_field:172.16.100.200->tun_src)
 673                 id += 85;
 674                 flow.setMatch(createMatch3().build());
 675                 flow.setInstructions(createTunnelIpv4SrcInstructions().build());
 676                 break;
 677             case "f86":
 678                 // Test Tunnel IPv4 Dst (e.g. set_field:172.16.100.100->tun_dst)
 679                 id += 86;
 680                 flow.setMatch(createMatch1().build());
 681                 flow.setInstructions(createTunnelIpv4DstInstructions().build());
 682                 break;
 683             default:
 684                 LOG.warn("flow type not understood: {}", flowType);
 685         }
 686
 687         final FlowKey key = new FlowKey(new FlowId(Long.toString(id)));
 688         if (null == flow.isBarrier()) {
 689             flow.setBarrier(Boolean.FALSE);
 690         }
 691         final BigInteger value = BigInteger.valueOf(10);
 692         flow.setCookie(new FlowCookie(value));
 693         flow.setCookieMask(new FlowCookie(value));
 694         flow.setHardTimeout(0);
 695         flow.setIdleTimeout(0);
 696         flow.setInstallHw(false);
 697         flow.setStrict(false);
 698         flow.setContainerName(null);
 699         flow.setFlags(new FlowModFlags(false, false, false, false, true));
 700         flow.setId(new FlowId("12"));
 701         flow.setTableId(getTableId(tableId));
 702
 703         flow.setKey(key);
 704         flow.setFlowName(ORIGINAL_FLOW_NAME + "X" + flowType);
 705         return flow;
 706     }
 707
 708
 709     private FlowBuilder createTestFlowPerfTest(final String flowTypeArg, final String tableId, final int id) {
 710         final FlowBuilder flow = new FlowBuilder();
 711         String flowType = flowTypeArg;
 712         int flowId = id;
 713
 714         if (flowType == null) {
 715             flowType = "f1";
 716         }
 717
 718         flow.setPriority(flowId);
 719
 720         switch (flowType) {
 721             case "f1":
 722                 flowId += 1;
 723                 flow.setMatch(createMatch1().build());
 724                 flow.setInstructions(createDecNwTtlInstructions().build());
 725                 break;
 726             default:
 727                 LOG.warn("flow type not understood: {}", flowType);
 728         }
 729
 730         final FlowKey key = new FlowKey(new FlowId(Long.toString(flowId)));
 731         if (null == flow.isBarrier()) {
 732             flow.setBarrier(Boolean.FALSE);
 733         }
 734         final BigInteger value = BigInteger.valueOf(10);
 735         flow.setCookie(new FlowCookie(value));
 736         flow.setCookieMask(new FlowCookie(value));
 737         flow.setHardTimeout(0);
 738         flow.setIdleTimeout(0);
 739         flow.setInstallHw(false);
 740         flow.setStrict(false);
 741         flow.setContainerName(null);
 742         flow.setFlags(new FlowModFlags(false, false, false, false, true));
 743         flow.setId(new FlowId("12"));
 744         flow.setTableId(getTableId(tableId));
 745
 746         flow.setKey(key);
 747         flow.setFlowName(ORIGINAL_FLOW_NAME + "X" + flowType);
 748         return flow;
 749     }
 750
 751     private FlowBuilder createtablemiss() {
 752         final FlowBuilder flow = new FlowBuilder();
 753         final long id = 456;
 754         final MatchBuilder matchBuilder = new MatchBuilder();
 755         flow.setMatch(matchBuilder.build());
 756         flow.setInstructions(createSentToControllerInstructions().build());
 757         flow.setPriority(0);
 758         flow.setTableId((short) 0);
 759         final FlowKey key = new FlowKey(new FlowId(Long.toString(id)));
 760         flow.setKey(key);
 761         return flow;
 762     }
 763
 764     private short getTableId(final String tableId) {
 765         final short TABLE_ID = 2;
 766         short table = TABLE_ID;
 767
 768         if (tableId == null) {
 769             return table;
 770         }
 771
 772         try {
 773             table = Short.parseShort(tableId);
 774         } catch (NumberFormatException ex) {
 775             LOG.info("Parsing String tableId {} failed. Continuing with default tableId {}.",
 776                     tableId, table);
 777         }
 778         return table;
 779     }
 780
 781     private static InstructionsBuilder createDecNwTtlInstructions() {
 782         final DecNwTtlBuilder ta = new DecNwTtlBuilder();
 783         final DecNwTtl decNwTtl = ta.build();
 784         final ActionBuilder ab = new ActionBuilder();
 785         ab.setAction(new DecNwTtlCaseBuilder().setDecNwTtl(decNwTtl).build());
 786         ab.setKey(new ActionKey(0));
 787         // Add our drop action to a list
 788         final List<Action> actionList = new ArrayList<>();
 789         actionList.add(ab.build());
 790
 791         // Create an Apply Action
 792         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 793         aab.setAction(actionList);
 794
 795         // Wrap our Apply Action in an Instruction
 796         final InstructionBuilder ib = new InstructionBuilder();
 797         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 798         ib.setKey(new InstructionKey(0));
 799         ib.setOrder(0);
 800
 801         // Put our Instruction in a list of Instructions
 802         final InstructionsBuilder isb = new InstructionsBuilder();
 803         final List<Instruction> instructions = new ArrayList<>();
 804         instructions.add(ib.build());
 805         ib.setKey(new InstructionKey(0));
 806         isb.setInstruction(instructions);
 807         return isb;
 808     }
 809
 810     private static InstructionsBuilder createMeterInstructions() {
 811
 812         final MeterBuilder aab = new MeterBuilder();
 813         aab.setMeterId(new MeterId(1L));
 814
 815         final InstructionBuilder ib = new InstructionBuilder();
 816         ib.setInstruction(new MeterCaseBuilder().setMeter(aab.build()).build());
 817
 818         // Put our Instruction in a list of Instructions
 819         final InstructionsBuilder isb = new InstructionsBuilder();
 820         final List<Instruction> instructions = new ArrayList<>();
 821         ib.setKey(new InstructionKey(0));
 822         instructions.add(ib.build());
 823         isb.setInstruction(instructions);
 824         return isb;
 825     }
 826
 827     private static InstructionsBuilder createMetadataInstructions() {
 828
 829         final WriteMetadataBuilder aab = new WriteMetadataBuilder();
 830         aab.setMetadata(BigInteger.valueOf(10));
 831         aab.setMetadataMask(BigInteger.valueOf(10));
 832
 833         final InstructionBuilder ib = new InstructionBuilder();
 834         ib.setInstruction(new WriteMetadataCaseBuilder().setWriteMetadata(aab.build()).build());
 835
 836         // Put our Instruction in a list of Instructions
 837         final InstructionsBuilder isb = new InstructionsBuilder();
 838         final List<Instruction> instructions = new ArrayList<>();
 839         ib.setKey(new InstructionKey(0));
 840         instructions.add(ib.build());
 841         isb.setInstruction(instructions);
 842         return isb;
 843     }
 844
 845     private static InstructionsBuilder createGotoTableInstructions() {
 846
 847         final GoToTableBuilder aab = new GoToTableBuilder();
 848         aab.setTableId((short) 5);
 849
 850         final InstructionBuilder ib = new InstructionBuilder();
 851         ib.setInstruction(new GoToTableCaseBuilder().setGoToTable(aab.build()).build());
 852
 853         // Put our Instruction in a list of Instructions
 854         final InstructionsBuilder isb = new InstructionsBuilder();
 855         final List<Instruction> instructions = new ArrayList<>();
 856         ib.setKey(new InstructionKey(0));
 857         instructions.add(ib.build());
 858         isb.setInstruction(instructions);
 859         return isb;
 860     }
 861
 862     private static InstructionsBuilder createDropInstructions() {
 863         final DropActionBuilder dab = new DropActionBuilder();
 864         final DropAction dropAction = dab.build();
 865         final ActionBuilder ab = new ActionBuilder();
 866         ab.setAction(new DropActionCaseBuilder().setDropAction(dropAction).build());
 867         ab.setKey(new ActionKey(0));
 868         // Add our drop action to a list
 869         final List<Action> actionList = new ArrayList<>();
 870         actionList.add(ab.build());
 871         ab.setKey(new ActionKey(0));
 872         // Create an Apply Action
 873         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 874         aab.setAction(actionList);
 875
 876         // Wrap our Apply Action in an Instruction
 877         final InstructionBuilder ib = new InstructionBuilder();
 878         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 879
 880         // Put our Instruction in a list of Instructions
 881         final InstructionsBuilder isb = new InstructionsBuilder();
 882         final List<Instruction> instructions = new ArrayList<>();
 883         ib.setKey(new InstructionKey(0));
 884         instructions.add(ib.build());
 885         isb.setInstruction(instructions);
 886         return isb;
 887     }
 888
 889     private static InstructionsBuilder createAppyActionInstruction() {
 890
 891         final List<Action> actionList = new ArrayList<>();
 892         final ActionBuilder ab = new ActionBuilder();
 893         final ControllerActionBuilder controller = new ControllerActionBuilder();
 894         controller.setMaxLength(5);
 895         ab.setAction(new ControllerActionCaseBuilder().setControllerAction(controller.build()).build());
 896         ab.setKey(new ActionKey(0));
 897         actionList.add(ab.build());
 898         // Create an Apply Action
 899         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 900         aab.setAction(actionList);
 901
 902         // Wrap our Apply Action in an Instruction
 903         final InstructionBuilder ib = new InstructionBuilder();
 904         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 905
 906         // Put our Instruction in a list of Instructions
 907         final InstructionsBuilder isb = new InstructionsBuilder();
 908         final List<Instruction> instructions = new ArrayList<>();
 909         ib.setKey(new InstructionKey(0));
 910         instructions.add(ib.build());
 911         isb.setInstruction(instructions);
 912         return isb;
 913     }
 914
 915     private static InstructionsBuilder createAppyActionInstruction1() {
 916
 917         final List<Action> actionList = new ArrayList<>();
 918         final ActionBuilder ab = new ActionBuilder();
 919
 920         final OutputActionBuilder output = new OutputActionBuilder();
 921         output.setMaxLength(56);
 922         final Uri value = new Uri("PCEP");
 923         output.setOutputNodeConnector(value);
 924         ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
 925         ab.setKey(new ActionKey(0));
 926         actionList.add(ab.build());
 927         // Create an Apply Action
 928         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 929         aab.setAction(actionList);
 930
 931         // Wrap our Apply Action in an Instruction
 932         final InstructionBuilder ib = new InstructionBuilder();
 933         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 934
 935         // Put our Instruction in a list of Instructions
 936         final InstructionsBuilder isb = new InstructionsBuilder();
 937         final List<Instruction> instructions = new ArrayList<>();
 938         ib.setKey(new InstructionKey(0));
 939         instructions.add(ib.build());
 940         isb.setInstruction(instructions);
 941         return isb;
 942     }
 943
 944     private static InstructionsBuilder createOutputInstructions() {
 945
 946         // test case for Output Port works if the particular port exists
 947         // this particular test-case is for Port : 1
 948         // tested as (addMDFlow openflow:<dpid> f82)
 949         final List<Action> actionList = new ArrayList<>();
 950         final ActionBuilder ab = new ActionBuilder();
 951         final OutputActionBuilder output = new OutputActionBuilder();
 952
 953         final Uri value = new Uri("1");
 954         output.setOutputNodeConnector(value);
 955         ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
 956         ab.setOrder(0);
 957         ab.setKey(new ActionKey(0));
 958         actionList.add(ab.build());
 959         // Create an Apply Action
 960         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 961         aab.setAction(actionList);
 962
 963         // Wrap our Apply Action in an Instruction
 964         final InstructionBuilder ib = new InstructionBuilder();
 965         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 966         ib.setOrder(0);
 967         ib.setKey(new InstructionKey(0));
 968
 969         // Put our Instruction in a list of Instructions
 970         final InstructionsBuilder isb = new InstructionsBuilder();
 971         final List<Instruction> instructions = new ArrayList<>();
 972         instructions.add(ib.build());
 973         isb.setInstruction(instructions);
 974         return isb;
 975     }
 976
 977     private static InstructionsBuilder createOutputInstructions(final String outputType, final int outputValue) {
 978         final List<Action> actionList = new ArrayList<>();
 979         final ActionBuilder ab = new ActionBuilder();
 980
 981         final OutputActionBuilder output = new OutputActionBuilder();
 982         output.setMaxLength(outputValue);
 983         final Uri value = new Uri(outputType);
 984         output.setOutputNodeConnector(value);
 985         ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
 986         ab.setOrder(0);
 987         ab.setKey(new ActionKey(0));
 988         actionList.add(ab.build());
 989         // Create an Apply Action
 990         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
 991         aab.setAction(actionList);
 992
 993         // Wrap our Apply Action in an Instruction
 994         final InstructionBuilder ib = new InstructionBuilder();
 995         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
 996         ib.setOrder(0);
 997         ib.setKey(new InstructionKey(0));
 998
 999         // Put our Instruction in a list of Instructions
1000         final InstructionsBuilder isb = new InstructionsBuilder();
1001         final List<Instruction> instructions = new ArrayList<>();
1002         instructions.add(ib.build());
1003         isb.setInstruction(instructions);
1004         return isb;
1005     }
1006
1007     private static InstructionsBuilder createSentToControllerInstructions() {
1008         final List<Action> actionList = new ArrayList<>();
1009         final ActionBuilder ab = new ActionBuilder();
1010
1011         final OutputActionBuilder output = new OutputActionBuilder();
1012         output.setMaxLength(Integer.valueOf(0xffff));
1013         final Uri value = new Uri(OutputPortValues.CONTROLLER.toString());
1014         output.setOutputNodeConnector(value);
1015         ab.setAction(new OutputActionCaseBuilder().setOutputAction(output.build()).build());
1016         ab.setOrder(0);
1017         ab.setKey(new ActionKey(0));
1018         actionList.add(ab.build());
1019         // Create an Apply Action
1020         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1021         aab.setAction(actionList);
1022
1023         // Wrap our Apply Action in an Instruction
1024         final InstructionBuilder ib = new InstructionBuilder();
1025         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1026         ib.setOrder(0);
1027         ib.setKey(new InstructionKey(0));
1028
1029         // Put our Instruction in a list of Instructions
1030         final InstructionsBuilder isb = new InstructionsBuilder();
1031         final List<Instruction> instructions = new ArrayList<>();
1032         instructions.add(ib.build());
1033         isb.setInstruction(instructions);
1034         return isb;
1035     }
1036
1037
1038     private static InstructionsBuilder createStripVlanInstructions() {
1039         final List<Action> actionList = new ArrayList<>();
1040         final ActionBuilder ab = new ActionBuilder();
1041
1042         final StripVlanActionBuilder stripActionBuilder = new StripVlanActionBuilder();
1043         ab.setAction(new StripVlanActionCaseBuilder().setStripVlanAction(stripActionBuilder.build()).build());
1044         ab.setOrder(0);
1045         ab.setKey(new ActionKey(0));
1046         actionList.add(ab.build());
1047         // Create an Apply Action
1048         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1049         aab.setAction(actionList);
1050
1051         // Wrap our Apply Action in an Instruction
1052         final InstructionBuilder ib = new InstructionBuilder();
1053         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1054         ib.setOrder(0);
1055         ib.setKey(new InstructionKey(0));
1056
1057         // Put our Instruction in a list of Instructions
1058         final InstructionsBuilder isb = new InstructionsBuilder();
1059         final List<Instruction> instructions = new ArrayList<>();
1060         instructions.add(ib.build());
1061         isb.setInstruction(instructions);
1062         return isb;
1063     }
1064
1065     private static InstructionsBuilder createAppyActionInstruction2() {
1066
1067         final List<Action> actionList = new ArrayList<>();
1068         final ActionBuilder ab = new ActionBuilder();
1069
1070         final PushMplsActionBuilder push = new PushMplsActionBuilder();
1071         push.setEthernetType(Integer.valueOf(0x8847));
1072         ab.setAction(new PushMplsActionCaseBuilder().setPushMplsAction(push.build()).build());
1073         ab.setKey(new ActionKey(0));
1074         actionList.add(ab.build());
1075         // Create an Apply Action
1076         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1077         aab.setAction(actionList);
1078
1079         // Wrap our Apply Action in an Instruction
1080         final InstructionBuilder ib = new InstructionBuilder();
1081         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1082
1083         // Put our Instruction in a list of Instructions
1084         final InstructionsBuilder isb = new InstructionsBuilder();
1085         final List<Instruction> instructions = new ArrayList<>();
1086         ib.setKey(new InstructionKey(0));
1087         instructions.add(ib.build());
1088         isb.setInstruction(instructions);
1089         return isb;
1090     }
1091
1092     private static InstructionsBuilder createAppyActionInstruction3() {
1093
1094         final List<Action> actionList = new ArrayList<>();
1095         final ActionBuilder ab = new ActionBuilder();
1096
1097         final PushPbbActionBuilder pbb = new PushPbbActionBuilder();
1098         pbb.setEthernetType(Integer.valueOf(0x88E7));
1099         ab.setAction(new PushPbbActionCaseBuilder().setPushPbbAction(pbb.build()).build());
1100         ab.setKey(new ActionKey(0));
1101         actionList.add(ab.build());
1102         // Create an Apply Action
1103         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1104         aab.setAction(actionList);
1105
1106         // Wrap our Apply Action in an Instruction
1107         final InstructionBuilder ib = new InstructionBuilder();
1108         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1109
1110         // Put our Instruction in a list of Instructions
1111         final InstructionsBuilder isb = new InstructionsBuilder();
1112         final List<Instruction> instructions = new ArrayList<>();
1113         ib.setKey(new InstructionKey(0));
1114         instructions.add(ib.build());
1115         isb.setInstruction(instructions);
1116         return isb;
1117     }
1118
1119     private static InstructionsBuilder createAppyActionInstruction4() {
1120
1121         final List<Action> actionList = new ArrayList<>();
1122         final ActionBuilder ab = new ActionBuilder();
1123
1124         final PushVlanActionBuilder vlan = new PushVlanActionBuilder();
1125         vlan.setEthernetType(Integer.valueOf(0x8100));
1126         ab.setAction(new PushVlanActionCaseBuilder().setPushVlanAction(vlan.build()).build());
1127         ab.setKey(new ActionKey(0));
1128         actionList.add(ab.build());
1129
1130         // Create an Apply Action
1131         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1132         aab.setAction(actionList);
1133
1134         // Wrap our Apply Action in an Instruction
1135         final InstructionBuilder ib = new InstructionBuilder();
1136         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1137
1138         // Put our Instruction in a list of Instructions
1139         final InstructionsBuilder isb = new InstructionsBuilder();
1140         final List<Instruction> instructions = new ArrayList<>();
1141         ib.setKey(new InstructionKey(0));
1142         instructions.add(ib.build());
1143         isb.setInstruction(instructions);
1144         return isb;
1145     }
1146
1147     private static InstructionsBuilder createAppyActionInstruction5() {
1148
1149         final List<Action> actionList = new ArrayList<>();
1150         final ActionBuilder ab = new ActionBuilder();
1151
1152         final SetDlDstActionBuilder setdl = new SetDlDstActionBuilder();
1153         setdl.setAddress(new MacAddress("00:05:b9:7c:81:5f"));
1154         ab.setAction(new SetDlDstActionCaseBuilder().setSetDlDstAction(setdl.build()).build());
1155         ab.setKey(new ActionKey(0));
1156         actionList.add(ab.build());
1157         // Create an Apply Action
1158         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1159         aab.setAction(actionList);
1160
1161         // Wrap our Apply Action in an Instruction
1162         final InstructionBuilder ib = new InstructionBuilder();
1163         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1164
1165         // Put our Instruction in a list of Instructions
1166         final InstructionsBuilder isb = new InstructionsBuilder();
1167         final List<Instruction> instructions = new ArrayList<>();
1168         ib.setKey(new InstructionKey(0));
1169         instructions.add(ib.build());
1170         isb.setInstruction(instructions);
1171         return isb;
1172     }
1173
1174     private static InstructionsBuilder createAppyActionInstruction6() {
1175
1176         final List<Action> actionList = new ArrayList<>();
1177         final ActionBuilder ab = new ActionBuilder();
1178
1179         final SetDlSrcActionBuilder src = new SetDlSrcActionBuilder();
1180         src.setAddress(new MacAddress("00:05:b9:7c:81:5f"));
1181         ab.setAction(new SetDlSrcActionCaseBuilder().setSetDlSrcAction(src.build()).build());
1182         ab.setKey(new ActionKey(0));
1183         actionList.add(ab.build());
1184
1185         // Create an Apply Action
1186         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1187         aab.setAction(actionList);
1188
1189         // Wrap our Apply Action in an Instruction
1190         final InstructionBuilder ib = new InstructionBuilder();
1191         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1192
1193         // Put our Instruction in a list of Instructions
1194         final InstructionsBuilder isb = new InstructionsBuilder();
1195         final List<Instruction> instructions = new ArrayList<>();
1196         ib.setKey(new InstructionKey(0));
1197         instructions.add(ib.build());
1198         isb.setInstruction(instructions);
1199         return isb;
1200     }
1201
1202     private static InstructionsBuilder createAppyActionInstruction7() {
1203
1204         final List<Action> actionList = new ArrayList<>();
1205         final ActionBuilder ab = new ActionBuilder();
1206
1207         final SetVlanIdActionBuilder vl = new SetVlanIdActionBuilder();
1208         final VlanId a = new VlanId(4000);
1209         vl.setVlanId(a);
1210         ab.setAction(new SetVlanIdActionCaseBuilder().setSetVlanIdAction(vl.build()).build());
1211         ab.setKey(new ActionKey(0));
1212         actionList.add(ab.build());
1213         // Create an Apply Action
1214         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1215         aab.setAction(actionList);
1216
1217         // Wrap our Apply Action in an Instruction
1218         final InstructionBuilder ib = new InstructionBuilder();
1219         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1220
1221         // Put our Instruction in a list of Instructions
1222         final InstructionsBuilder isb = new InstructionsBuilder();
1223         final List<Instruction> instructions = new ArrayList<>();
1224         ib.setKey(new InstructionKey(0));
1225         instructions.add(ib.build());
1226         isb.setInstruction(instructions);
1227         return isb;
1228     }
1229
1230     private static InstructionsBuilder createAppyActionInstruction8() {
1231
1232         final List<Action> actionList = new ArrayList<>();
1233         final ActionBuilder ab = new ActionBuilder();
1234
1235         final SetVlanPcpActionBuilder pcp = new SetVlanPcpActionBuilder();
1236         final VlanPcp pcp1 = new VlanPcp((short) 2);
1237         pcp.setVlanPcp(pcp1);
1238         ab.setAction(new SetVlanPcpActionCaseBuilder().setSetVlanPcpAction(pcp.build()).build());
1239         ab.setKey(new ActionKey(0));
1240         actionList.add(ab.build());
1241         // Create an Apply Action
1242         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1243         aab.setAction(actionList);
1244
1245         // Wrap our Apply Action in an Instruction
1246         final InstructionBuilder ib = new InstructionBuilder();
1247         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1248
1249         // Put our Instruction in a list of Instructions
1250         final InstructionsBuilder isb = new InstructionsBuilder();
1251         final List<Instruction> instructions = new ArrayList<>();
1252         ib.setKey(new InstructionKey(0));
1253         instructions.add(ib.build());
1254         isb.setInstruction(instructions);
1255         return isb;
1256     }
1257
1258     private static InstructionsBuilder createAppyActionInstruction88() {
1259
1260         final List<Action> actionList = new ArrayList<>();
1261         final ActionBuilder ab = new ActionBuilder();
1262
1263         final SetVlanPcpActionBuilder pcp = new SetVlanPcpActionBuilder();
1264         // the code point is a 3-bit(0-7) field representing the frame priority level
1265         final VlanPcp pcp1 = new VlanPcp((short) 4);
1266         pcp.setVlanPcp(pcp1);
1267         ab.setAction(new SetVlanPcpActionCaseBuilder().setSetVlanPcpAction(pcp.build()).build());
1268         ab.setKey(new ActionKey(0));
1269         actionList.add(ab.build());
1270         // Create an Apply Action
1271         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1272         aab.setAction(actionList);
1273
1274         // Wrap our Apply Action in an Instruction
1275         final InstructionBuilder ib = new InstructionBuilder();
1276         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1277
1278         // Put our Instruction in a list of Instructions
1279         final InstructionsBuilder isb = new InstructionsBuilder();
1280         final List<Instruction> instructions = new ArrayList<>();
1281         ib.setKey(new InstructionKey(0));
1282         instructions.add(ib.build());
1283         isb.setInstruction(instructions);
1284         return isb;
1285     }
1286
1287     private static InstructionsBuilder createAppyActionInstruction9() {
1288
1289         final List<Action> actionList = new ArrayList<>();
1290         final ActionBuilder ab = new ActionBuilder();
1291
1292         final CopyTtlInBuilder ttlin = new CopyTtlInBuilder();
1293         ab.setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(ttlin.build()).build());
1294         ab.setKey(new ActionKey(0));
1295         actionList.add(ab.build());
1296         // Create an Apply Action
1297         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1298         aab.setAction(actionList);
1299
1300         // Wrap our Apply Action in an Instruction
1301         final InstructionBuilder ib = new InstructionBuilder();
1302         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1303
1304         // Put our Instruction in a list of Instructions
1305         final InstructionsBuilder isb = new InstructionsBuilder();
1306         final List<Instruction> instructions = new ArrayList<>();
1307         ib.setKey(new InstructionKey(0));
1308         instructions.add(ib.build());
1309         isb.setInstruction(instructions);
1310         return isb;
1311     }
1312
1313     private static InstructionsBuilder createAppyActionInstruction10() {
1314
1315         final List<Action> actionList = new ArrayList<>();
1316         final ActionBuilder ab = new ActionBuilder();
1317
1318         final CopyTtlOutBuilder ttlout = new CopyTtlOutBuilder();
1319         ab.setAction(new CopyTtlOutCaseBuilder().setCopyTtlOut(ttlout.build()).build());
1320         ab.setKey(new ActionKey(0));
1321         actionList.add(ab.build());
1322         // Create an Apply Action
1323         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1324         aab.setAction(actionList);
1325
1326         // Wrap our Apply Action in an Instruction
1327         final InstructionBuilder ib = new InstructionBuilder();
1328         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1329
1330         // Put our Instruction in a list of Instructions
1331         final InstructionsBuilder isb = new InstructionsBuilder();
1332         final List<Instruction> instructions = new ArrayList<>();
1333         ib.setKey(new InstructionKey(0));
1334         instructions.add(ib.build());
1335         isb.setInstruction(instructions);
1336         return isb;
1337     }
1338
1339     private static InstructionsBuilder createAppyActionInstruction11() {
1340
1341         final List<Action> actionList = new ArrayList<>();
1342         final ActionBuilder ab = new ActionBuilder();
1343
1344         final DecMplsTtlBuilder mpls = new DecMplsTtlBuilder();
1345         ab.setAction(new DecMplsTtlCaseBuilder().setDecMplsTtl(mpls.build()).build());
1346         ab.setKey(new ActionKey(0));
1347         actionList.add(ab.build());
1348         // Create an Apply Action
1349         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1350         aab.setAction(actionList);
1351
1352         // Wrap our Apply Action in an Instruction
1353         final InstructionBuilder ib = new InstructionBuilder();
1354         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1355         ib.setKey(new InstructionKey(0));
1356         ib.setOrder(0);
1357
1358         // Put our Instruction in a list of Instruction
1359         final InstructionsBuilder isb = new InstructionsBuilder();
1360         final List<Instruction> instructions = new ArrayList<>();
1361         instructions.add(ib.build());
1362         isb.setInstruction(instructions);
1363         return isb;
1364     }
1365
1366     private static InstructionsBuilder createAppyActionInstruction12() {
1367
1368         final List<Action> actionList = new ArrayList<>();
1369         final ActionBuilder ab = new ActionBuilder();
1370
1371         final DecNwTtlBuilder nwttl = new DecNwTtlBuilder();
1372         ab.setAction(new DecNwTtlCaseBuilder().setDecNwTtl(nwttl.build()).build());
1373         ab.setKey(new ActionKey(0));
1374         actionList.add(ab.build());
1375
1376         // Create an Apply Action
1377         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1378         aab.setAction(actionList);
1379
1380         // Wrap our Apply Action in an Instruction
1381         final InstructionBuilder ib = new InstructionBuilder();
1382         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1383
1384         // Put our Instruction in a list of Instructions
1385         final InstructionsBuilder isb = new InstructionsBuilder();
1386         final List<Instruction> instructions = new ArrayList<>();
1387         ib.setKey(new InstructionKey(0));
1388         instructions.add(ib.build());
1389         isb.setInstruction(instructions);
1390         return isb;
1391     }
1392
1393     private static InstructionsBuilder createAppyActionInstruction13() {
1394
1395         final List<Action> actionList = new ArrayList<>();
1396         final ActionBuilder ab = new ActionBuilder();
1397
1398         final DropActionBuilder drop = new DropActionBuilder();
1399         ab.setAction(new DropActionCaseBuilder().setDropAction(drop.build()).build());
1400         ab.setKey(new ActionKey(0));
1401         actionList.add(ab.build());
1402
1403         // Create an Apply Action
1404         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1405         aab.setAction(actionList);
1406
1407         // Wrap our Apply Action in an Instruction
1408         final InstructionBuilder ib = new InstructionBuilder();
1409         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1410
1411         // Put our Instruction in a list of Instructions
1412         final InstructionsBuilder isb = new InstructionsBuilder();
1413         final List<Instruction> instructions = new ArrayList<>();
1414         ib.setKey(new InstructionKey(0));
1415         instructions.add(ib.build());
1416         isb.setInstruction(instructions);
1417         return isb;
1418     }
1419
1420     private static InstructionsBuilder createAppyActionInstruction14() {
1421
1422         final List<Action> actionList = new ArrayList<>();
1423         final ActionBuilder ab = new ActionBuilder();
1424
1425         final FloodActionBuilder fld = new FloodActionBuilder();
1426         ab.setAction(new FloodActionCaseBuilder().setFloodAction(fld.build()).build());
1427         ab.setKey(new ActionKey(0));
1428         actionList.add(ab.build());
1429         // Create an Apply Action
1430         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1431         aab.setAction(actionList);
1432
1433         // Wrap our Apply Action in an Instruction
1434         final InstructionBuilder ib = new InstructionBuilder();
1435         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1436
1437         // Put our Instruction in a list of Instructions
1438         final InstructionsBuilder isb = new InstructionsBuilder();
1439         final List<Instruction> instructions = new ArrayList<>();
1440         ib.setKey(new InstructionKey(0));
1441         instructions.add(ib.build());
1442         isb.setInstruction(instructions);
1443         return isb;
1444     }
1445
1446     private static InstructionsBuilder createAppyActionInstruction15() {
1447
1448         final List<Action> actionList = new ArrayList<>();
1449         final ActionBuilder ab = new ActionBuilder();
1450
1451         final FloodAllActionBuilder fldall = new FloodAllActionBuilder();
1452         ab.setAction(new FloodAllActionCaseBuilder().setFloodAllAction(fldall.build()).build());
1453         ab.setKey(new ActionKey(0));
1454         actionList.add(ab.build());
1455         // Create an Apply Action
1456         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1457         aab.setAction(actionList);
1458
1459         // Wrap our Apply Action in an Instruction
1460         final InstructionBuilder ib = new InstructionBuilder();
1461         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1462
1463         // Put our Instruction in a list of Instructions
1464         final InstructionsBuilder isb = new InstructionsBuilder();
1465         final List<Instruction> instructions = new ArrayList<>();
1466         ib.setKey(new InstructionKey(0));
1467         instructions.add(ib.build());
1468         isb.setInstruction(instructions);
1469         return isb;
1470     }
1471
1472     private static InstructionsBuilder createAppyActionInstruction16() {
1473
1474         final List<Action> actionList = new ArrayList<>();
1475         final ActionBuilder ab = new ActionBuilder();
1476
1477         final GroupActionBuilder groupActionB = new GroupActionBuilder();
1478         groupActionB.setGroupId(1L);
1479         groupActionB.setGroup("0");
1480         ab.setAction(new GroupActionCaseBuilder().setGroupAction(groupActionB.build()).build());
1481         ab.setKey(new ActionKey(0));
1482         actionList.add(ab.build());
1483
1484         // Create an Apply Action
1485         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1486         aab.setAction(actionList);
1487
1488         // Wrap our Apply Action in an Instruction
1489         final InstructionBuilder ib = new InstructionBuilder();
1490         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1491
1492         // Put our Instruction in a list of Instructions
1493         final InstructionsBuilder isb = new InstructionsBuilder();
1494         final List<Instruction> instructions = new ArrayList<>();
1495         ib.setKey(new InstructionKey(0));
1496         instructions.add(ib.build());
1497         isb.setInstruction(instructions);
1498         return isb;
1499     }
1500
1501     private static InstructionsBuilder createAppyActionInstruction17() {
1502
1503         final List<Action> actionList = new ArrayList<>();
1504         final ActionBuilder ab = new ActionBuilder();
1505
1506         final HwPathActionBuilder hwPathB = new HwPathActionBuilder();
1507         ab.setAction(new HwPathActionCaseBuilder().setHwPathAction(hwPathB.build()).build());
1508         ab.setKey(new ActionKey(0));
1509         actionList.add(ab.build());
1510         // Create an Apply Action
1511         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1512         aab.setAction(actionList);
1513
1514         // Wrap our Apply Action in an Instruction
1515         final InstructionBuilder ib = new InstructionBuilder();
1516         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1517
1518         // Put our Instruction in a list of Instructions
1519         final InstructionsBuilder isb = new InstructionsBuilder();
1520         final List<Instruction> instructions = new ArrayList<>();
1521         ib.setKey(new InstructionKey(0));
1522         instructions.add(ib.build());
1523         isb.setInstruction(instructions);
1524         return isb;
1525     }
1526
1527     private static InstructionsBuilder createAppyActionInstruction18() {
1528
1529         final List<Action> actionList = new ArrayList<>();
1530         final ActionBuilder ab = new ActionBuilder();
1531
1532         final LoopbackActionBuilder loopbackActionBuilder = new LoopbackActionBuilder();
1533         ab.setAction(new LoopbackActionCaseBuilder().setLoopbackAction(loopbackActionBuilder.build()).build());
1534         ab.setKey(new ActionKey(0));
1535         actionList.add(ab.build());
1536
1537         // Create an Apply Action
1538         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1539         aab.setAction(actionList);
1540
1541         // Wrap our Apply Action in an Instruction
1542         final InstructionBuilder ib = new InstructionBuilder();
1543         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1544
1545         // Put our Instruction in a list of Instructions
1546         final InstructionsBuilder isb = new InstructionsBuilder();
1547         final List<Instruction> instructions = new ArrayList<>();
1548         ib.setKey(new InstructionKey(0));
1549         instructions.add(ib.build());
1550         isb.setInstruction(instructions);
1551         return isb;
1552     }
1553
1554     private static InstructionsBuilder createAppyActionInstruction19() {
1555
1556         final List<Action> actionList = new ArrayList<>();
1557         final ActionBuilder ab = new ActionBuilder();
1558
1559         final PopMplsActionBuilder popMplsActionBuilder = new PopMplsActionBuilder();
1560         popMplsActionBuilder.setEthernetType(0XB);
1561         ab.setAction(new PopMplsActionCaseBuilder().setPopMplsAction(popMplsActionBuilder.build()).build());
1562         ab.setKey(new ActionKey(0));
1563         actionList.add(ab.build());
1564         // Create an Apply Action
1565         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1566         aab.setAction(actionList);
1567
1568         // Wrap our Apply Action in an Instruction
1569         final InstructionBuilder ib = new InstructionBuilder();
1570         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1571
1572         // Put our Instruction in a list of Instructions
1573         final InstructionsBuilder isb = new InstructionsBuilder();
1574         final List<Instruction> instructions = new ArrayList<>();
1575         ib.setKey(new InstructionKey(0));
1576         instructions.add(ib.build());
1577         isb.setInstruction(instructions);
1578         return isb;
1579     }
1580
1581     private static InstructionsBuilder createAppyActionInstruction20() {
1582
1583         final List<Action> actionList = new ArrayList<>();
1584         final ActionBuilder ab = new ActionBuilder();
1585
1586         final PopPbbActionBuilder popPbbActionBuilder = new PopPbbActionBuilder();
1587         ab.setAction(new PopPbbActionCaseBuilder().setPopPbbAction(popPbbActionBuilder.build()).build());
1588         ab.setKey(new ActionKey(0));
1589         actionList.add(ab.build());
1590         // Create an Apply Action
1591         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1592         aab.setAction(actionList);
1593
1594         // Wrap our Apply Action in an Instruction
1595         final InstructionBuilder ib = new InstructionBuilder();
1596         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1597
1598         // Put our Instruction in a list of Instructions
1599         final InstructionsBuilder isb = new InstructionsBuilder();
1600         final List<Instruction> instructions = new ArrayList<>();
1601         ib.setKey(new InstructionKey(0));
1602         instructions.add(ib.build());
1603         isb.setInstruction(instructions);
1604         return isb;
1605     }
1606
1607     private static InstructionsBuilder createAppyActionInstruction21() {
1608
1609         final List<Action> actionList = new ArrayList<>();
1610         final ActionBuilder ab = new ActionBuilder();
1611
1612         final PopVlanActionBuilder popVlanActionBuilder = new PopVlanActionBuilder();
1613         ab.setAction(new PopVlanActionCaseBuilder().setPopVlanAction(popVlanActionBuilder.build()).build());
1614         ab.setKey(new ActionKey(0));
1615         actionList.add(ab.build());
1616
1617         // Create an Apply Action
1618         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1619         aab.setAction(actionList);
1620
1621         // Wrap our Apply Action in an Instruction
1622         final InstructionBuilder ib = new InstructionBuilder();
1623         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1624
1625         // Put our Instruction in a list of Instructions
1626         final InstructionsBuilder isb = new InstructionsBuilder();
1627         final List<Instruction> instructions = new ArrayList<>();
1628         ib.setKey(new InstructionKey(0));
1629         instructions.add(ib.build());
1630         isb.setInstruction(instructions);
1631         return isb;
1632     }
1633
1634     private static InstructionsBuilder createAppyActionInstruction22() {
1635
1636         final List<Action> actionList = new ArrayList<>();
1637         final ActionBuilder ab = new ActionBuilder();
1638
1639         final SetDlTypeActionBuilder setDlTypeActionBuilder = new SetDlTypeActionBuilder();
1640         setDlTypeActionBuilder.setDlType(new EtherType(8L));
1641         ab.setAction(new SetDlTypeActionCaseBuilder().setSetDlTypeAction(setDlTypeActionBuilder.build()).build());
1642         ab.setKey(new ActionKey(0));
1643         actionList.add(ab.build());
1644
1645         // Create an Apply Action
1646         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1647         aab.setAction(actionList);
1648
1649         // Wrap our Apply Action in an Instruction
1650         final InstructionBuilder ib = new InstructionBuilder();
1651         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1652
1653         // Put our Instruction in a list of Instructions
1654         final InstructionsBuilder isb = new InstructionsBuilder();
1655         final List<Instruction> instructions = new ArrayList<>();
1656         ib.setKey(new InstructionKey(0));
1657         instructions.add(ib.build());
1658         isb.setInstruction(instructions);
1659         return isb;
1660     }
1661
1662     private static InstructionsBuilder createAppyActionInstruction23(final NodeId nodeId) {
1663
1664         final List<Action> actionList = new ArrayList<>();
1665         final ActionBuilder ab = new ActionBuilder();
1666
1667         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
1668         setFieldBuilder.setInPort(new NodeConnectorId(nodeId + ":2"));
1669         ab.setKey(new ActionKey(0));
1670         actionList.add(ab.build());
1671
1672         // Create an Apply Action
1673         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1674         aab.setAction(actionList);
1675
1676         // Wrap our Apply Action in an Instruction
1677         final InstructionBuilder ib = new InstructionBuilder();
1678         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1679
1680         // Put our Instruction in a list of Instructions
1681         final InstructionsBuilder isb = new InstructionsBuilder();
1682         final List<Instruction> instructions = new ArrayList<>();
1683         ib.setKey(new InstructionKey(0));
1684         instructions.add(ib.build());
1685         isb.setInstruction(instructions);
1686         return isb;
1687     }
1688
1689     private static InstructionsBuilder createAppyActionInstruction24() {
1690
1691         final List<Action> actionList = new ArrayList<>();
1692         final ActionBuilder ab = new ActionBuilder();
1693
1694         final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
1695         setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
1696         ab.setAction(new SetMplsTtlActionCaseBuilder().setSetMplsTtlAction(setMplsTtlActionBuilder.build()).build());
1697         ab.setKey(new ActionKey(0));
1698         actionList.add(ab.build());
1699
1700         // Create an Apply Action
1701         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1702         aab.setAction(actionList);
1703
1704         // Wrap our Apply Action in an Instruction
1705         final InstructionBuilder ib = new InstructionBuilder();
1706         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1707
1708         // Put our Instruction in a list of Instructions
1709         final InstructionsBuilder isb = new InstructionsBuilder();
1710         final List<Instruction> instructions = new ArrayList<>();
1711         ib.setKey(new InstructionKey(0));
1712         instructions.add(ib.build());
1713         isb.setInstruction(instructions);
1714         return isb;
1715     }
1716
1717     private static InstructionsBuilder createAppyActionInstruction25() {
1718
1719         final List<Action> actionList = new ArrayList<>();
1720         final ActionBuilder ab = new ActionBuilder();
1721
1722         final SetNextHopActionBuilder setNextHopActionBuilder = new SetNextHopActionBuilder();
1723         final Ipv4Builder ipnext = new Ipv4Builder();
1724         final Ipv4Prefix prefix = new Ipv4Prefix(IPV4_PREFIX);
1725         ipnext.setIpv4Address(prefix);
1726         setNextHopActionBuilder.setAddress(ipnext.build());
1727         ab.setAction(new SetNextHopActionCaseBuilder().setSetNextHopAction(setNextHopActionBuilder.build()).build());
1728         ab.setKey(new ActionKey(0));
1729         actionList.add(ab.build());
1730
1731         // Create an Apply Action
1732         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1733         aab.setAction(actionList);
1734
1735         // Wrap our Apply Action in an Instruction
1736         final InstructionBuilder ib = new InstructionBuilder();
1737         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1738
1739         // Put our Instruction in a list of Instructions
1740         final InstructionsBuilder isb = new InstructionsBuilder();
1741         final List<Instruction> instructions = new ArrayList<>();
1742         ib.setKey(new InstructionKey(0));
1743         instructions.add(ib.build());
1744         isb.setInstruction(instructions);
1745         return isb;
1746     }
1747
1748     private static InstructionsBuilder createAppyActionInstruction26() {
1749
1750         final List<Action> actionList = new ArrayList<>();
1751         final ActionBuilder ab = new ActionBuilder();
1752
1753         final SetNwDstActionBuilder setNwDstActionBuilder = new SetNwDstActionBuilder();
1754         final Ipv4Builder ipdst = new Ipv4Builder();
1755         final Ipv4Prefix prefixdst = new Ipv4Prefix("10.0.0.21/24");
1756         ipdst.setIpv4Address(prefixdst);
1757         setNwDstActionBuilder.setAddress(ipdst.build());
1758         ab.setAction(new SetNwDstActionCaseBuilder().setSetNwDstAction(setNwDstActionBuilder.build()).build());
1759         ab.setKey(new ActionKey(0));
1760         actionList.add(ab.build());
1761
1762         // Create an Apply Action
1763         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1764         aab.setAction(actionList);
1765
1766         // Wrap our Apply Action in an Instruction
1767         final InstructionBuilder ib = new InstructionBuilder();
1768         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1769
1770         // Put our Instruction in a list of Instructions
1771         final InstructionsBuilder isb = new InstructionsBuilder();
1772         final List<Instruction> instructions = new ArrayList<>();
1773         ib.setKey(new InstructionKey(0));
1774         instructions.add(ib.build());
1775         isb.setInstruction(instructions);
1776         return isb;
1777     }
1778
1779     private static InstructionsBuilder createAppyActionInstruction27() {
1780
1781         final List<Action> actionList = new ArrayList<>();
1782         final ActionBuilder ab = new ActionBuilder();
1783
1784         final SetNwSrcActionBuilder setNwsrcActionBuilder = new SetNwSrcActionBuilder();
1785         final Ipv4Builder ipsrc = new Ipv4Builder();
1786         final Ipv4Prefix prefixsrc = new Ipv4Prefix("10.0.23.21/24");
1787         ipsrc.setIpv4Address(prefixsrc);
1788         setNwsrcActionBuilder.setAddress(ipsrc.build());
1789         ab.setAction(new SetNwSrcActionCaseBuilder().setSetNwSrcAction(setNwsrcActionBuilder.build()).build());
1790         ab.setKey(new ActionKey(0));
1791         actionList.add(ab.build());
1792
1793         // Create an Apply Action
1794         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1795         aab.setAction(actionList);
1796
1797         // Wrap our Apply Action in an Instruction
1798         final InstructionBuilder ib = new InstructionBuilder();
1799         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1800
1801         // Put our Instruction in a list of Instructions
1802         final InstructionsBuilder isb = new InstructionsBuilder();
1803         final List<Instruction> instructions = new ArrayList<>();
1804         ib.setKey(new InstructionKey(0));
1805         instructions.add(ib.build());
1806         isb.setInstruction(instructions);
1807         return isb;
1808     }
1809
1810     private static InstructionsBuilder createAppyActionInstruction28() {
1811
1812         final List<Action> actionList = new ArrayList<>();
1813         final ActionBuilder ab = new ActionBuilder();
1814
1815         final SetNwTosActionBuilder setNwTosActionBuilder = new SetNwTosActionBuilder();
1816         setNwTosActionBuilder.setTos(8);
1817         ab.setAction(new SetNwTosActionCaseBuilder().setSetNwTosAction(setNwTosActionBuilder.build()).build());
1818         ab.setKey(new ActionKey(0));
1819         actionList.add(ab.build());
1820         // Create an Apply Action
1821         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1822         aab.setAction(actionList);
1823
1824         // Wrap our Apply Action in an Instruction
1825         final InstructionBuilder ib = new InstructionBuilder();
1826         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1827
1828         // Put our Instruction in a list of Instructions
1829         final InstructionsBuilder isb = new InstructionsBuilder();
1830         final List<Instruction> instructions = new ArrayList<>();
1831         ib.setKey(new InstructionKey(0));
1832         instructions.add(ib.build());
1833         isb.setInstruction(instructions);
1834         return isb;
1835     }
1836
1837     private static InstructionsBuilder createAppyActionInstruction29() {
1838
1839         final List<Action> actionList = new ArrayList<>();
1840         final ActionBuilder ab = new ActionBuilder();
1841
1842         final SetNwTtlActionBuilder setNwTtlActionBuilder = new SetNwTtlActionBuilder();
1843         setNwTtlActionBuilder.setNwTtl((short) 1);
1844         ab.setAction(new SetNwTtlActionCaseBuilder().setSetNwTtlAction(setNwTtlActionBuilder.build()).build());
1845         ab.setKey(new ActionKey(0));
1846         actionList.add(ab.build());
1847
1848         // Create an Apply Action
1849         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1850         aab.setAction(actionList);
1851
1852         // Wrap our Apply Action in an Instruction
1853         final InstructionBuilder ib = new InstructionBuilder();
1854         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1855
1856         // Put our Instruction in a list of Instructions
1857         final InstructionsBuilder isb = new InstructionsBuilder();
1858         final List<Instruction> instructions = new ArrayList<>();
1859         ib.setKey(new InstructionKey(0));
1860         instructions.add(ib.build());
1861         isb.setInstruction(instructions);
1862         return isb;
1863     }
1864
1865     private static InstructionsBuilder createAppyActionInstruction30() {
1866
1867         final List<Action> actionList = new ArrayList<>();
1868         final ActionBuilder ab = new ActionBuilder();
1869
1870         final SetQueueActionBuilder setQueueActionBuilder = new SetQueueActionBuilder();
1871         setQueueActionBuilder.setQueueId(1L);
1872         ab.setAction(new SetQueueActionCaseBuilder().setSetQueueAction(setQueueActionBuilder.build()).build());
1873         ab.setKey(new ActionKey(0));
1874         actionList.add(ab.build());
1875         // Create an Apply Action
1876         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1877         aab.setAction(actionList);
1878
1879         // Wrap our Apply Action in an Instruction
1880         final InstructionBuilder ib = new InstructionBuilder();
1881         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1882
1883         // Put our Instruction in a list of Instructions
1884         final InstructionsBuilder isb = new InstructionsBuilder();
1885         final List<Instruction> instructions = new ArrayList<>();
1886         ib.setKey(new InstructionKey(0));
1887         instructions.add(ib.build());
1888         isb.setInstruction(instructions);
1889         return isb;
1890     }
1891
1892     private static InstructionsBuilder createAppyActionInstruction31() {
1893
1894         final List<Action> actionList = new ArrayList<>();
1895         final ActionBuilder ab = new ActionBuilder();
1896
1897         final SetTpDstActionBuilder setTpDstActionBuilder = new SetTpDstActionBuilder();
1898         setTpDstActionBuilder.setPort(new PortNumber(109));
1899
1900         ab.setAction(new SetTpDstActionCaseBuilder().setSetTpDstAction(setTpDstActionBuilder.build()).build());
1901         ab.setKey(new ActionKey(0));
1902         actionList.add(ab.build());
1903         // Create an Apply Action
1904         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1905         aab.setAction(actionList);
1906
1907         // Wrap our Apply Action in an Instruction
1908         final InstructionBuilder ib = new InstructionBuilder();
1909         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1910
1911         // Put our Instruction in a list of Instructions
1912         final InstructionsBuilder isb = new InstructionsBuilder();
1913         final List<Instruction> instructions = new ArrayList<>();
1914         ib.setKey(new InstructionKey(0));
1915         instructions.add(ib.build());
1916         isb.setInstruction(instructions);
1917         return isb;
1918     }
1919
1920     private static InstructionsBuilder createAppyActionInstruction32() {
1921
1922         final List<Action> actionList = new ArrayList<>();
1923         final ActionBuilder ab = new ActionBuilder();
1924
1925         final SetTpSrcActionBuilder setTpSrcActionBuilder = new SetTpSrcActionBuilder();
1926         setTpSrcActionBuilder.setPort(new PortNumber(109));
1927         ab.setAction(new SetTpSrcActionCaseBuilder().setSetTpSrcAction(setTpSrcActionBuilder.build()).build());
1928         ab.setKey(new ActionKey(0));
1929         actionList.add(ab.build());
1930
1931         // Create an Apply Action
1932         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1933         aab.setAction(actionList);
1934
1935         // Wrap our Apply Action in an Instruction
1936         final InstructionBuilder ib = new InstructionBuilder();
1937         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1938
1939         // Put our Instruction in a list of Instructions
1940         final InstructionsBuilder isb = new InstructionsBuilder();
1941         final List<Instruction> instructions = new ArrayList<>();
1942         ib.setKey(new InstructionKey(0));
1943         instructions.add(ib.build());
1944         isb.setInstruction(instructions);
1945         return isb;
1946     }
1947
1948     private static InstructionsBuilder createAppyActionInstruction33() {
1949
1950         final List<Action> actionList = new ArrayList<>();
1951         final ActionBuilder ab = new ActionBuilder();
1952
1953         final SetVlanCfiActionBuilder setVlanCfiActionBuilder = new SetVlanCfiActionBuilder();
1954         setVlanCfiActionBuilder.setVlanCfi(new VlanCfi(2));
1955         ab.setAction(new SetVlanCfiActionCaseBuilder().setSetVlanCfiAction(setVlanCfiActionBuilder.build()).build());
1956         ab.setKey(new ActionKey(0));
1957         actionList.add(ab.build());
1958
1959         // Create an Apply Action
1960         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1961         aab.setAction(actionList);
1962
1963         // Wrap our Apply Action in an Instruction
1964         final InstructionBuilder ib = new InstructionBuilder();
1965         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1966
1967         // Put our Instruction in a list of Instructions
1968         final InstructionsBuilder isb = new InstructionsBuilder();
1969         final List<Instruction> instructions = new ArrayList<>();
1970         ib.setKey(new InstructionKey(0));
1971         instructions.add(ib.build());
1972         isb.setInstruction(instructions);
1973         return isb;
1974     }
1975
1976     private static InstructionsBuilder createAppyActionInstruction34() {
1977
1978         final List<Action> actionList = new ArrayList<>();
1979         final ActionBuilder ab = new ActionBuilder();
1980
1981         final SwPathActionBuilder swPathAction = new SwPathActionBuilder();
1982         ab.setAction(new SwPathActionCaseBuilder().setSwPathAction(swPathAction.build()).build());
1983         ab.setKey(new ActionKey(0));
1984         actionList.add(ab.build());
1985
1986         // Create an Apply Action
1987         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
1988         aab.setAction(actionList);
1989
1990         // Wrap our Apply Action in an Instruction
1991         final InstructionBuilder ib = new InstructionBuilder();
1992         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
1993
1994         // Put our Instruction in a list of Instructions
1995         final InstructionsBuilder isb = new InstructionsBuilder();
1996         final List<Instruction> instructions = new ArrayList<>();
1997         ib.setKey(new InstructionKey(0));
1998         instructions.add(ib.build());
1999         isb.setInstruction(instructions);
2000         return isb;
2001     }
2002
2003     private static InstructionsBuilder createAppyActionInstruction35() {
2004
2005         final List<Action> actionList = new ArrayList<>();
2006         final ActionBuilder ab = new ActionBuilder();
2007         final ActionBuilder ab1 = new ActionBuilder();
2008         final ActionBuilder ab2 = new ActionBuilder();
2009
2010         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2011         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2012         final SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
2013
2014         // Ethernet
2015         final EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
2016         final EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
2017         ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
2018         final EthernetMatchBuilder ethernetMatch1 = new EthernetMatchBuilder();
2019         final EthernetDestinationBuilder ethDestBuilder = new EthernetDestinationBuilder();
2020         ethDestBuilder.setAddress(new MacAddress("00:00:00:00:00:02"));
2021         final EthernetMatchBuilder ethernetMatch2 = new EthernetMatchBuilder();
2022         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2023         ethTypeBuilder.setType(new EtherType(0x86ddL));
2024
2025         ethernetMatch.setEthernetSource(ethSourceBuilder.build());
2026         ethernetMatch1.setEthernetDestination(ethDestBuilder.build());
2027         ethernetMatch2.setEthernetType(ethTypeBuilder.build());
2028         setFieldBuilder.setEthernetMatch(ethernetMatch.build());
2029         setFieldBuilder1.setEthernetMatch(ethernetMatch1.build());
2030         setFieldBuilder2.setEthernetMatch(ethernetMatch2.build());
2031         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2032         ab.setKey(new ActionKey(0));
2033         actionList.add(ab.build());
2034
2035         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2036         ab1.setKey(new ActionKey(1));
2037         actionList.add(ab1.build());
2038
2039         ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
2040         ab2.setKey(new ActionKey(2));
2041         actionList.add(ab2.build());
2042
2043         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2044         aab.setAction(actionList);
2045
2046         final InstructionBuilder ib = new InstructionBuilder();
2047         ib.setKey(new InstructionKey(0));
2048         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2049
2050         // Put our Instruction in a list of Instructions
2051         final InstructionsBuilder isb = new InstructionsBuilder();
2052         final List<Instruction> instructions = new ArrayList<>();
2053         ib.setKey(new InstructionKey(0));
2054         instructions.add(ib.build());
2055         isb.setInstruction(instructions);
2056         return isb;
2057     }
2058
2059     private static InstructionsBuilder createAppyActionInstruction36() {
2060
2061         final List<Action> actionList = new ArrayList<>();
2062         final ActionBuilder ab = new ActionBuilder();
2063         final ActionBuilder ab1 = new ActionBuilder();
2064
2065         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2066         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2067
2068         // Vlan
2069         final VlanMatchBuilder vlanBuilder = new VlanMatchBuilder();
2070         final VlanMatchBuilder vlanBuilder1 = new VlanMatchBuilder();
2071         final VlanIdBuilder vlanIdBuilder = new VlanIdBuilder();
2072         final VlanId vlanId = new VlanId(10);
2073         final VlanPcp vpcp = new VlanPcp((short) 3);
2074         vlanBuilder.setVlanPcp(vpcp);
2075         vlanBuilder1.setVlanId(vlanIdBuilder.setVlanId(vlanId).setVlanIdPresent(true).build());
2076         setFieldBuilder.setVlanMatch(vlanBuilder.build());
2077         setFieldBuilder1.setVlanMatch(vlanBuilder1.build());
2078         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2079         ab.setKey(new ActionKey(0));
2080         actionList.add(ab.build());
2081         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2082         ab1.setKey(new ActionKey(1));
2083         actionList.add(ab1.build());
2084
2085         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2086         aab.setAction(actionList);
2087
2088         final InstructionBuilder ib = new InstructionBuilder();
2089         ib.setKey(new InstructionKey(0));
2090         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2091
2092         // Put our Instruction in a list of Instructions
2093         final InstructionsBuilder isb = new InstructionsBuilder();
2094         final List<Instruction> instructions = new ArrayList<>();
2095         instructions.add(ib.build());
2096         isb.setInstruction(instructions);
2097         return isb;
2098     }
2099
2100     private static InstructionsBuilder createAppyActionInstruction37() {
2101
2102         final List<Action> actionList = new ArrayList<>();
2103         final ActionBuilder ab = new ActionBuilder();
2104         final ActionBuilder ab1 = new ActionBuilder();
2105         final ActionBuilder ab2 = new ActionBuilder();
2106
2107         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2108         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2109         final SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
2110         // Ip
2111         final IpMatchBuilder ipmatch = new IpMatchBuilder();
2112         final IpMatchBuilder ipmatch1 = new IpMatchBuilder();
2113         final IpMatchBuilder ipmatch2 = new IpMatchBuilder();
2114         final Dscp dscp = new Dscp((short) 3);
2115         ipmatch.setIpDscp(dscp);
2116         ipmatch1.setIpEcn((short) 2);
2117         ipmatch2.setIpProtocol((short) 120);
2118         setFieldBuilder.setIpMatch(ipmatch.build());
2119         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2120         ab.setKey(new ActionKey(0));
2121         actionList.add(ab.build());
2122
2123         setFieldBuilder1.setIpMatch(ipmatch1.build());
2124         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2125         ab1.setKey(new ActionKey(1));
2126         actionList.add(ab1.build());
2127
2128         setFieldBuilder2.setIpMatch(ipmatch2.build());
2129         ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
2130         ab2.setKey(new ActionKey(2));
2131         actionList.add(ab2.build());
2132
2133         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2134         aab.setAction(actionList);
2135
2136         final InstructionBuilder ib = new InstructionBuilder();
2137         ib.setKey(new InstructionKey(0));
2138         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2139
2140         // Put our Instruction in a list of Instructions
2141         final InstructionsBuilder isb = new InstructionsBuilder();
2142         final List<Instruction> instructions = new ArrayList<>();
2143         instructions.add(ib.build());
2144         isb.setInstruction(instructions);
2145         return isb;
2146     }
2147
2148     private static InstructionsBuilder createAppyActionInstruction38() {
2149
2150         final List<Action> actionList = new ArrayList<>();
2151         final ActionBuilder ab = new ActionBuilder();
2152         final ActionBuilder ab1 = new ActionBuilder();
2153
2154         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2155         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2156         // IPv4
2157         final Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
2158         final Ipv4MatchBuilder ipv4Match1 = new Ipv4MatchBuilder();
2159         final Ipv4Prefix dstip = new Ipv4Prefix("200.71.9.5210");
2160         final Ipv4Prefix srcip = new Ipv4Prefix("100.1.1.1");
2161         ipv4Match1.setIpv4Destination(dstip);
2162         ipv4Match.setIpv4Source(srcip);
2163         setFieldBuilder.setLayer3Match(ipv4Match.build());
2164         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2165         ab.setKey(new ActionKey(0));
2166         actionList.add(ab.build());
2167
2168         setFieldBuilder1.setLayer3Match(ipv4Match1.build());
2169         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2170         ab1.setKey(new ActionKey(1));
2171         actionList.add(ab1.build());
2172
2173         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2174         aab.setAction(actionList);
2175
2176         final InstructionBuilder ib = new InstructionBuilder();
2177         ib.setKey(new InstructionKey(0));
2178         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2179
2180         // Put our Instruction in a list of Instructions
2181         final InstructionsBuilder isb = new InstructionsBuilder();
2182         final List<Instruction> instructions = new ArrayList<>();
2183         instructions.add(ib.build());
2184         isb.setInstruction(instructions);
2185         return isb;
2186     }
2187
2188     private static InstructionsBuilder createAppyActionInstruction39() {
2189
2190         final List<Action> actionList = new ArrayList<>();
2191         final ActionBuilder ab = new ActionBuilder();
2192         final ActionBuilder ab1 = new ActionBuilder();
2193
2194         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2195         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2196
2197         // Tcp
2198         final PortNumber tcpsrcport = new PortNumber(1213);
2199         final PortNumber tcpdstport = new PortNumber(646);
2200         final TcpMatchBuilder tcpmatch = new TcpMatchBuilder();
2201         final TcpMatchBuilder tcpmatch1 = new TcpMatchBuilder();
2202         tcpmatch.setTcpSourcePort(tcpsrcport);
2203         tcpmatch1.setTcpDestinationPort(tcpdstport);
2204         setFieldBuilder.setLayer4Match(tcpmatch.build());
2205         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2206         ab.setKey(new ActionKey(0));
2207         actionList.add(ab.build());
2208
2209         setFieldBuilder1.setLayer4Match(tcpmatch1.build());
2210         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2211         ab1.setKey(new ActionKey(1));
2212         actionList.add(ab.build());
2213
2214         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2215         aab.setAction(actionList);
2216
2217         final InstructionBuilder ib = new InstructionBuilder();
2218         ib.setKey(new InstructionKey(0));
2219         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2220
2221         // Put our Instruction in a list of Instructions
2222         final InstructionsBuilder isb = new InstructionsBuilder();
2223         final List<Instruction> instructions = new ArrayList<>();
2224         instructions.add(ib.build());
2225         isb.setInstruction(instructions);
2226         return isb;
2227     }
2228
2229     private static InstructionsBuilder createAppyActionInstruction40() {
2230
2231         final List<Action> actionList = new ArrayList<>();
2232         final ActionBuilder ab = new ActionBuilder();
2233         final ActionBuilder ab1 = new ActionBuilder();
2234
2235         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2236         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2237
2238         // Udp
2239         final PortNumber udpsrcport = new PortNumber(1325);
2240         final PortNumber udpdstport = new PortNumber(42);
2241         final UdpMatchBuilder udpmatch = new UdpMatchBuilder();
2242         final UdpMatchBuilder udpmatch1 = new UdpMatchBuilder();
2243         udpmatch.setUdpDestinationPort(udpdstport);
2244         udpmatch1.setUdpSourcePort(udpsrcport);
2245         setFieldBuilder.setLayer4Match(udpmatch.build());
2246         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2247         ab.setKey(new ActionKey(0));
2248         actionList.add(ab.build());
2249
2250         setFieldBuilder1.setLayer4Match(udpmatch1.build());
2251         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2252         ab1.setKey(new ActionKey(1));
2253         actionList.add(ab1.build());
2254
2255         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2256         aab.setAction(actionList);
2257
2258         final InstructionBuilder ib = new InstructionBuilder();
2259         ib.setKey(new InstructionKey(0));
2260         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2261
2262         // Put our Instruction in a list of Instructions
2263         final InstructionsBuilder isb = new InstructionsBuilder();
2264         final List<Instruction> instructions = new ArrayList<>();
2265         instructions.add(ib.build());
2266         isb.setInstruction(instructions);
2267         return isb;
2268     }
2269
2270     private static InstructionsBuilder createAppyActionInstruction41() {
2271
2272         final List<Action> actionList = new ArrayList<>();
2273         final ActionBuilder ab = new ActionBuilder();
2274         final ActionBuilder ab1 = new ActionBuilder();
2275
2276         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2277         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2278
2279         // Sctp
2280         final SctpMatchBuilder sctpmatch = new SctpMatchBuilder();
2281         final SctpMatchBuilder sctpmatch1 = new SctpMatchBuilder();
2282         final PortNumber srcport = new PortNumber(1435);
2283         final PortNumber dstport = new PortNumber(22);
2284         sctpmatch.setSctpSourcePort(srcport);
2285         sctpmatch1.setSctpDestinationPort(dstport);
2286         setFieldBuilder.setLayer4Match(sctpmatch.build());
2287         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2288         ab.setKey(new ActionKey(0));
2289         actionList.add(ab.build());
2290
2291         setFieldBuilder1.setLayer4Match(sctpmatch1.build());
2292         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2293         ab1.setKey(new ActionKey(1));
2294         actionList.add(ab1.build());
2295
2296         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2297         aab.setAction(actionList);
2298
2299         final InstructionBuilder ib = new InstructionBuilder();
2300         ib.setKey(new InstructionKey(0));
2301         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2302
2303         // Put our Instruction in a list of Instructions
2304         final InstructionsBuilder isb = new InstructionsBuilder();
2305         final List<Instruction> instructions = new ArrayList<>();
2306         instructions.add(ib.build());
2307         isb.setInstruction(instructions);
2308         return isb;
2309     }
2310
2311     private static InstructionsBuilder createAppyActionInstruction42() {
2312
2313         final List<Action> actionList = new ArrayList<>();
2314         final ActionBuilder ab = new ActionBuilder();
2315         final ActionBuilder ab1 = new ActionBuilder();
2316         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2317         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2318
2319         // Icmpv4
2320         final Icmpv4MatchBuilder icmpv4match = new Icmpv4MatchBuilder();
2321         final Icmpv4MatchBuilder icmpv4match1 = new Icmpv4MatchBuilder();
2322         icmpv4match.setIcmpv4Type((short) 8);
2323         icmpv4match1.setIcmpv4Code((short) 0);
2324         setFieldBuilder.setIcmpv4Match(icmpv4match.build());
2325         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2326         ab.setKey(new ActionKey(0));
2327         actionList.add(ab.build());
2328
2329         setFieldBuilder1.setIcmpv4Match(icmpv4match1.build());
2330         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2331         ab1.setKey(new ActionKey(1));
2332         actionList.add(ab1.build());
2333
2334         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2335         aab.setAction(actionList);
2336
2337         final InstructionBuilder ib = new InstructionBuilder();
2338         ib.setKey(new InstructionKey(0));
2339         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2340
2341         // Put our Instruction in a list of Instructions
2342         final InstructionsBuilder isb = new InstructionsBuilder();
2343         final List<Instruction> instructions = new ArrayList<>();
2344         instructions.add(ib.build());
2345         isb.setInstruction(instructions);
2346         return isb;
2347     }
2348
2349     private static InstructionsBuilder createAppyActionInstruction43() {
2350
2351         final List<Action> actionList = new ArrayList<>();
2352         final ActionBuilder ab = new ActionBuilder();
2353         final ActionBuilder ab1 = new ActionBuilder();
2354         final ActionBuilder ab2 = new ActionBuilder();
2355         final ActionBuilder ab3 = new ActionBuilder();
2356         final ActionBuilder ab4 = new ActionBuilder();
2357
2358         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2359         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2360         final SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
2361         final SetFieldBuilder setFieldBuilder3 = new SetFieldBuilder();
2362         final SetFieldBuilder setFieldBuilder4 = new SetFieldBuilder();
2363
2364         // setting the values of ARP
2365         final MacAddress macdest = new MacAddress(DEST_MAC_ADDRESS);
2366         final MacAddress macsrc = new MacAddress(SRC_MAC_ADDRESS);
2367         final Ipv4Prefix dstiparp = new Ipv4Prefix("200.71.9.52");
2368         final Ipv4Prefix srciparp = new Ipv4Prefix("100.1.1.1");
2369         // create ARP match action
2370         final ArpMatchBuilder arpmatch = new ArpMatchBuilder();
2371         final ArpMatchBuilder arpmatch1 = new ArpMatchBuilder();
2372         final ArpMatchBuilder arpmatch2 = new ArpMatchBuilder();
2373         final ArpMatchBuilder arpmatch3 = new ArpMatchBuilder();
2374         final ArpMatchBuilder arpmatch4 = new ArpMatchBuilder();
2375         final ArpSourceHardwareAddressBuilder arpsrc = new ArpSourceHardwareAddressBuilder();
2376         arpsrc.setAddress(macsrc);
2377         final ArpTargetHardwareAddressBuilder arpdst = new ArpTargetHardwareAddressBuilder();
2378         arpdst.setAddress(macdest);
2379         arpmatch.setArpOp(2);
2380         arpmatch1.setArpSourceHardwareAddress(arpsrc.build());
2381         arpmatch2.setArpTargetHardwareAddress(arpdst.build());
2382         arpmatch3.setArpSourceTransportAddress(srciparp);
2383         arpmatch4.setArpTargetTransportAddress(dstiparp);
2384         setFieldBuilder.setLayer3Match(arpmatch.build());
2385         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2386         ab.setKey(new ActionKey(0));
2387         actionList.add(ab.build());
2388
2389         setFieldBuilder1.setLayer3Match(arpmatch1.build());
2390         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2391         ab1.setKey(new ActionKey(1));
2392         actionList.add(ab1.build());
2393
2394         setFieldBuilder2.setLayer3Match(arpmatch2.build());
2395         ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
2396         ab2.setKey(new ActionKey(2));
2397         actionList.add(ab2.build());
2398
2399         setFieldBuilder3.setLayer3Match(arpmatch3.build());
2400         ab3.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder3.build()).build());
2401         ab3.setKey(new ActionKey(3));
2402         actionList.add(ab3.build());
2403
2404         setFieldBuilder4.setLayer3Match(arpmatch4.build());
2405         ab4.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder4.build()).build());
2406         ab4.setKey(new ActionKey(4));
2407         actionList.add(ab4.build());
2408
2409         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2410         aab.setAction(actionList);
2411
2412         final InstructionBuilder ib = new InstructionBuilder();
2413         ib.setKey(new InstructionKey(0));
2414         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2415
2416         // Put our Instruction in a list of Instructions
2417         final InstructionsBuilder isb = new InstructionsBuilder();
2418         final List<Instruction> instructions = new ArrayList<>();
2419         instructions.add(ib.build());
2420         isb.setInstruction(instructions);
2421         return isb;
2422     }
2423
2424     private static InstructionsBuilder createAppyActionInstruction44() {
2425
2426         final List<Action> actionLists = new ArrayList<>();
2427         final ActionBuilder ab = new ActionBuilder();
2428         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2429         final ActionBuilder ab1 = new ActionBuilder();
2430         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2431         final ActionBuilder ab5 = new ActionBuilder();
2432         final SetFieldBuilder setFieldBuilder5 = new SetFieldBuilder();
2433         final ActionBuilder ab6 = new ActionBuilder();
2434         final SetFieldBuilder setFieldBuilder6 = new SetFieldBuilder();
2435
2436         // IPv6
2437         final Ipv6MatchBuilder ipv6Builder = new Ipv6MatchBuilder();
2438         final Ipv6MatchBuilder ipv6Builder1 = new Ipv6MatchBuilder();
2439         final Ipv6MatchBuilder ipv6Builder5 = new Ipv6MatchBuilder();
2440         final Ipv6MatchBuilder ipv6Builder6 = new Ipv6MatchBuilder();
2441
2442         final Ipv6Prefix dstip6 = new Ipv6Prefix("2002::2/128");
2443         final Ipv6Prefix srcip6 = new Ipv6Prefix("2001:0:0:0:0:0:0:1/128");
2444         final Ipv6ExtHeaderBuilder nextheader = new Ipv6ExtHeaderBuilder();
2445         nextheader.setIpv6Exthdr(58);
2446         final Ipv6LabelBuilder ipv6label = new Ipv6LabelBuilder();
2447         final Ipv6FlowLabel label = new Ipv6FlowLabel(10028L);
2448         ipv6label.setIpv6Flabel(label);
2449
2450         ipv6Builder.setIpv6Source(srcip6);
2451         ipv6Builder1.setIpv6Destination(dstip6);
2452         ipv6Builder5.setIpv6ExtHeader(nextheader.build());
2453         ipv6Builder6.setIpv6Label(ipv6label.build());
2454
2455         setFieldBuilder.setLayer3Match(ipv6Builder.build());
2456         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2457         ab.setKey(new ActionKey(0));
2458         actionLists.add(ab.build());
2459
2460         setFieldBuilder1.setLayer3Match(ipv6Builder1.build());
2461         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2462         ab1.setKey(new ActionKey(1));
2463         actionLists.add(ab1.build());
2464
2465         setFieldBuilder5.setLayer3Match(ipv6Builder5.build());
2466         ab5.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder5.build()).build());
2467         ab5.setKey(new ActionKey(5));
2468         actionLists.add(ab5.build());
2469
2470         setFieldBuilder6.setLayer3Match(ipv6Builder6.build());
2471         ab6.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder6.build()).build());
2472         ab6.setKey(new ActionKey(6));
2473         actionLists.add(ab6.build());
2474
2475         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2476         aab.setAction(actionLists);
2477
2478         final InstructionBuilder ib = new InstructionBuilder();
2479         ib.setKey(new InstructionKey(0));
2480         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2481
2482         // Put our Instruction in a list of Instructions
2483         final InstructionsBuilder isb = new InstructionsBuilder();
2484         final List<Instruction> instructions = new ArrayList<>();
2485         instructions.add(ib.build());
2486         isb.setInstruction(instructions);
2487         return isb;
2488     }
2489
2490     private static InstructionsBuilder createAppyActionInstruction45() {
2491
2492         final List<Action> actionList = new ArrayList<>();
2493         final ActionBuilder ab = new ActionBuilder();
2494         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2495         final ActionBuilder ab1 = new ActionBuilder();
2496         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2497
2498         // Icmpv6
2499         final Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder();
2500         final Icmpv6MatchBuilder icmpv6match1 = new Icmpv6MatchBuilder();
2501         icmpv6match.setIcmpv6Type((short) 135);
2502         icmpv6match1.setIcmpv6Code((short) 0);
2503         setFieldBuilder.setIcmpv6Match(icmpv6match.build());
2504         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2505         ab.setKey(new ActionKey(0));
2506         actionList.add(ab.build());
2507
2508         setFieldBuilder1.setIcmpv6Match(icmpv6match1.build());
2509         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2510         ab1.setKey(new ActionKey(1));
2511         actionList.add(ab1.build());
2512
2513         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2514         aab.setAction(actionList);
2515
2516         final InstructionBuilder ib = new InstructionBuilder();
2517         ib.setKey(new InstructionKey(0));
2518         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2519
2520         // Put our Instruction in a list of Instructions
2521         final InstructionsBuilder isb = new InstructionsBuilder();
2522         final List<Instruction> instructions = new ArrayList<>();
2523         instructions.add(ib.build());
2524         isb.setInstruction(instructions);
2525         return isb;
2526     }
2527
2528     private static InstructionsBuilder createAppyActionInstruction46() {
2529
2530         final List<Action> actionList = new ArrayList<>();
2531         final ActionBuilder ab = new ActionBuilder();
2532         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2533         final ActionBuilder ab1 = new ActionBuilder();
2534         final SetFieldBuilder setFieldBuilder1 = new SetFieldBuilder();
2535         final ActionBuilder ab2 = new ActionBuilder();
2536         final SetFieldBuilder setFieldBuilder2 = new SetFieldBuilder();
2537
2538         // MPLS
2539         final ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder();
2540         final ProtocolMatchFieldsBuilder protomatch1 = new ProtocolMatchFieldsBuilder();
2541         final ProtocolMatchFieldsBuilder protomatch2 = new ProtocolMatchFieldsBuilder();
2542         protomatch.setMplsLabel((long) 36008);
2543         protomatch1.setMplsTc((short) 4);
2544         protomatch2.setMplsBos((short) 1);
2545         setFieldBuilder.setProtocolMatchFields(protomatch.build());
2546         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2547         ab.setKey(new ActionKey(0));
2548         actionList.add(ab.build());
2549
2550         setFieldBuilder1.setProtocolMatchFields(protomatch1.build());
2551         ab1.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder1.build()).build());
2552         ab1.setKey(new ActionKey(1));
2553         actionList.add(ab1.build());
2554
2555         setFieldBuilder2.setProtocolMatchFields(protomatch2.build());
2556         ab2.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder2.build()).build());
2557         ab2.setKey(new ActionKey(2));
2558         actionList.add(ab2.build());
2559
2560         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2561         aab.setAction(actionList);
2562
2563         final InstructionBuilder ib = new InstructionBuilder();
2564         ib.setKey(new InstructionKey(0));
2565         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2566
2567         // Put our Instruction in a list of Instructions
2568         final InstructionsBuilder isb = new InstructionsBuilder();
2569         final List<Instruction> instructions = new ArrayList<>();
2570         instructions.add(ib.build());
2571         isb.setInstruction(instructions);
2572         return isb;
2573     }
2574
2575     private static InstructionsBuilder createAppyActionInstruction47() {
2576
2577         final List<Action> actionList = new ArrayList<>();
2578         final ActionBuilder ab = new ActionBuilder();
2579         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2580         // PBB
2581         final ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder();
2582         protomatch.setPbb(new PbbBuilder().setPbbIsid(4L).setPbbMask(
2583                 new BigInteger(new byte[]{0, 1, 0, 0}).longValue()).build());
2584         setFieldBuilder.setProtocolMatchFields(protomatch.build());
2585         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2586         actionList.add(ab.build());
2587
2588         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2589         aab.setAction(actionList);
2590
2591         final InstructionBuilder ib = new InstructionBuilder();
2592         ib.setKey(new InstructionKey(0));
2593         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2594
2595         // Put our Instruction in a list of Instructions
2596         final InstructionsBuilder isb = new InstructionsBuilder();
2597         final List<Instruction> instructions = new ArrayList<>();
2598         instructions.add(ib.build());
2599         isb.setInstruction(instructions);
2600         return isb;
2601     }
2602
2603     private static InstructionsBuilder createAppyActionInstruction48() {
2604
2605         final List<Action> actionList = new ArrayList<>();
2606         final ActionBuilder ab = new ActionBuilder();
2607         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2608         // Tunnel
2609         final TunnelBuilder tunnel = new TunnelBuilder();
2610         tunnel.setTunnelId(BigInteger.valueOf(10668));
2611         setFieldBuilder.setTunnel(tunnel.build());
2612         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2613         ab.setKey(new ActionKey(0));
2614         actionList.add(ab.build());
2615
2616         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2617         aab.setAction(actionList);
2618
2619         final InstructionBuilder ib = new InstructionBuilder();
2620         ib.setKey(new InstructionKey(0));
2621         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2622
2623         // Put our Instruction in a list of Instructions
2624         final InstructionsBuilder isb = new InstructionsBuilder();
2625         final List<Instruction> instructions = new ArrayList<>();
2626         instructions.add(ib.build());
2627         isb.setInstruction(instructions);
2628         return isb;
2629     }
2630
2631     private static InstructionsBuilder createTunnelIpv4DstInstructions() {
2632
2633         final List<Action> actionList = new ArrayList<>();
2634         final ActionBuilder ab = new ActionBuilder();
2635         // Build the tunnel endpoint destination IPv4 address
2636         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2637         final Ipv4Prefix dstIp = new Ipv4Prefix("172.16.100.100");
2638         // Add the mew IPv4 object as the tunnel destination
2639         final TunnelIpv4MatchBuilder tunnelIpv4DstMatchBuilder = new TunnelIpv4MatchBuilder();
2640         tunnelIpv4DstMatchBuilder.setTunnelIpv4Destination(dstIp);
2641         setFieldBuilder.setLayer3Match(tunnelIpv4DstMatchBuilder.build());
2642         // Add the IPv4 tunnel dst to the set_field value
2643         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2644         ab.setOrder(0);
2645         ab.setKey(new ActionKey(0));
2646         actionList.add(ab.build());
2647         // Resulting action is a per/flow src TEP (set_field:172.16.100.100->tun_dst)
2648         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2649         aab.setAction(actionList);
2650         // Add the action to the ordered list of Instructions
2651         final InstructionBuilder ib = new InstructionBuilder();
2652         ib.setOrder(0);
2653         ib.setKey(new InstructionKey(0));
2654         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2655         // Add the Instruction in a list of Instructions
2656         final InstructionsBuilder isb = new InstructionsBuilder();
2657         final List<Instruction> instructions = new ArrayList<>();
2658         instructions.add(ib.build());
2659         isb.setInstruction(instructions);
2660         return isb;
2661     }
2662
2663     private static InstructionsBuilder createTunnelIpv4SrcInstructions() {
2664
2665         final List<Action> actionList = new ArrayList<>();
2666         final ActionBuilder ab = new ActionBuilder();
2667         // Build the tunnel endpoint source IPv4 address
2668         final SetFieldBuilder setFieldBuilder = new SetFieldBuilder();
2669         final Ipv4Prefix dstIp = new Ipv4Prefix("172.16.100.200");
2670         // Add the new IPv4 object as the tunnel destination
2671         final TunnelIpv4MatchBuilder tunnelIpv4MatchBuilder = new TunnelIpv4MatchBuilder();
2672         tunnelIpv4MatchBuilder.setTunnelIpv4Source(dstIp);
2673         setFieldBuilder.setLayer3Match(tunnelIpv4MatchBuilder.build());
2674         // Add the IPv4 tunnel src to the set_field value
2675         ab.setAction(new SetFieldCaseBuilder().setSetField(setFieldBuilder.build()).build());
2676         ab.setOrder(0);
2677         ab.setKey(new ActionKey(0));
2678         actionList.add(ab.build());
2679         // Resulting action is a per/flow src TEP (set_field:172.16.100.100->tun_src)
2680         final ApplyActionsBuilder aab = new ApplyActionsBuilder();
2681         aab.setAction(actionList);
2682         // Add the action to the ordered list of Instructions
2683         final InstructionBuilder ib = new InstructionBuilder();
2684         ib.setOrder(0);
2685         ib.setKey(new InstructionKey(0));
2686         ib.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(aab.build()).build());
2687         // Put our Instruction in a list of Instructions
2688         final InstructionsBuilder isb = new InstructionsBuilder();
2689         final List<Instruction> instructions = new ArrayList<>();
2690         instructions.add(ib.build());
2691         isb.setInstruction(instructions);
2692         return isb;
2693     }
2694
2695     private static MatchBuilder createLLDPMatch() {
2696         final MatchBuilder match = new MatchBuilder();
2697         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2698         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2699         ethTypeBuilder.setType(new EtherType(0x88ccL));
2700         eth.setEthernetType(ethTypeBuilder.build());
2701         match.setEthernetMatch(eth.build());
2702         return match;
2703     }
2704
2705     private static MatchBuilder createMatch1() {
2706         final MatchBuilder match = new MatchBuilder();
2707         final Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
2708         final Ipv4Prefix prefix = new Ipv4Prefix(IPV4_PREFIX);
2709         ipv4Match.setIpv4Destination(prefix);
2710         final Ipv4Match i4m = ipv4Match.build();
2711         match.setLayer3Match(i4m);
2712
2713         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2714         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2715         ethTypeBuilder.setType(new EtherType(0x0800L));
2716         eth.setEthernetType(ethTypeBuilder.build());
2717         match.setEthernetMatch(eth.build());
2718         return match;
2719     }
2720
2721     private static MatchBuilder createMatch2() {
2722         final MatchBuilder match = new MatchBuilder();
2723         final Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
2724         final Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.1");
2725         ipv4Match.setIpv4Source(prefix);
2726         final Ipv4Match i4m = ipv4Match.build();
2727         match.setLayer3Match(i4m);
2728
2729         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2730         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2731         ethTypeBuilder.setType(new EtherType(0x0800L));
2732         eth.setEthernetType(ethTypeBuilder.build());
2733         match.setEthernetMatch(eth.build());
2734         return match;
2735     }
2736
2737     private static MatchBuilder createMatch3() {
2738         final MatchBuilder match = new MatchBuilder();
2739         final EthernetMatchBuilder ethernetMatch = new EthernetMatchBuilder();
2740         final EthernetSourceBuilder ethSourceBuilder = new EthernetSourceBuilder();
2741         ethSourceBuilder.setAddress(new MacAddress("00:00:00:00:00:01"));
2742         ethernetMatch.setEthernetSource(ethSourceBuilder.build());
2743         match.setEthernetMatch(ethernetMatch.build());
2744
2745         return match;
2746     }
2747
2748     private static MatchBuilder createICMPv6Match1() {
2749
2750         final MatchBuilder match = new MatchBuilder();
2751         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2752         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2753         ethTypeBuilder.setType(new EtherType(0x86ddL));
2754         eth.setEthernetType(ethTypeBuilder.build());
2755         match.setEthernetMatch(eth.build());
2756
2757         // ipv4 version
2758         final IpMatchBuilder ipmatch = new IpMatchBuilder();
2759         ipmatch.setIpProtocol((short) 256);
2760         match.setIpMatch(ipmatch.build());
2761
2762         // icmpv6
2763         final Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder();
2764
2765         // match
2766         icmpv6match.setIcmpv6Type((short) 135);
2767         icmpv6match.setIcmpv6Code((short) 1);
2768         match.setIcmpv6Match(icmpv6match.build());
2769
2770         return match;
2771     }
2772
2773     private static MatchBuilder createMatch33() {
2774
2775         final MatchBuilder match = new MatchBuilder();
2776         final Ipv4MatchBuilder ipv4Match = new Ipv4MatchBuilder();
2777         final Ipv4Prefix prefix = new Ipv4Prefix("10.0.0.10");
2778         ipv4Match.setIpv4Source(prefix);
2779         final Ipv4Match i4m = ipv4Match.build();
2780         match.setLayer3Match(i4m);
2781
2782         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2783         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2784         ethTypeBuilder.setType(new EtherType(0xfffeL));
2785         eth.setEthernetType(ethTypeBuilder.build());
2786         match.setEthernetMatch(eth.build());
2787         return match;
2788     }
2789
2790     private static MatchBuilder createInphyportMatch(final NodeId nodeId) {
2791         final MatchBuilder match = new MatchBuilder();
2792         match.setInPort(new NodeConnectorId(nodeId + ":202"));
2793         match.setInPhyPort(new NodeConnectorId(nodeId + ":10122"));
2794         return match;
2795     }
2796
2797     private static MatchBuilder createEthernetMatch() {
2798         final MatchBuilder match = new MatchBuilder();
2799         final EthernetMatchBuilder ethmatch = new EthernetMatchBuilder(); // ethernettype
2800         // match
2801         final EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
2802         final EtherType type = new EtherType(0x0800L);
2803         ethmatch.setEthernetType(ethtype.setType(type).build());
2804
2805         final EthernetDestinationBuilder ethdest = new EthernetDestinationBuilder(); // ethernet
2806         // macaddress
2807         // match
2808         final MacAddress macdest = new MacAddress(DEST_MAC_ADDRESS);
2809         ethdest.setAddress(macdest);
2810         ethdest.setMask(new MacAddress("ff:ff:ff:00:00:00"));
2811
2812         ethmatch.setEthernetDestination(ethdest.build());
2813
2814         final EthernetSourceBuilder ethsrc = new EthernetSourceBuilder();
2815         final MacAddress macsrc = new MacAddress(SRC_MAC_ADDRESS);
2816         ethsrc.setAddress(macsrc);
2817         ethsrc.setMask(new MacAddress("ff:ff:00:00:00:00"));
2818
2819         ethmatch.setEthernetSource(ethsrc.build());
2820         match.setEthernetMatch(ethmatch.build());
2821         return match;
2822
2823     }
2824
2825     private static MatchBuilder createVlanMatch() {
2826         final MatchBuilder match = new MatchBuilder();
2827         // vlan match
2828         final VlanMatchBuilder vlanBuilder = new VlanMatchBuilder();
2829         final VlanIdBuilder vlanIdBuilder = new VlanIdBuilder();
2830         final VlanId vlanId = new VlanId(10);
2831         final VlanPcp vpcp = new VlanPcp((short) 3);
2832         vlanBuilder.setVlanPcp(vpcp);
2833         vlanIdBuilder.setVlanId(vlanId);
2834         vlanIdBuilder.setVlanIdPresent(true);
2835         vlanBuilder.setVlanId(vlanIdBuilder.build());
2836         match.setVlanMatch(vlanBuilder.build());
2837         return match;
2838     }
2839
2840     private static MatchBuilder createArpMatch() {
2841         final MatchBuilder match = new MatchBuilder();
2842
2843         final EthernetMatchBuilder ethmatch = new EthernetMatchBuilder();
2844         final MacAddress macdest = new MacAddress(DEST_MAC_ADDRESS);
2845         final MacAddress macsrc = new MacAddress(SRC_MAC_ADDRESS);
2846
2847         final EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
2848         final EtherType type = new EtherType(0x0806L);
2849         ethmatch.setEthernetType(ethtype.setType(type).build());
2850
2851         // ipv4 match
2852         final Ipv4Prefix dstip = new Ipv4Prefix("200.71.9.52/10");
2853         final Ipv4Prefix srcip = new Ipv4Prefix("100.1.1.1/8");
2854
2855         // arp match
2856         final ArpMatchBuilder arpmatch = new ArpMatchBuilder();
2857         final ArpSourceHardwareAddressBuilder arpsrc = new ArpSourceHardwareAddressBuilder();
2858         arpsrc.setAddress(macsrc);
2859         arpsrc.setMask(new MacAddress("ff:ff:ff:00:00:00"));
2860         final ArpTargetHardwareAddressBuilder arpdst = new ArpTargetHardwareAddressBuilder();
2861         arpdst.setAddress(macdest);
2862         arpdst.setMask(new MacAddress("ff:ff:00:00:00:00"));
2863         arpmatch.setArpOp(2);
2864         arpmatch.setArpSourceHardwareAddress(arpsrc.build());
2865         arpmatch.setArpTargetHardwareAddress(arpdst.build());
2866         arpmatch.setArpSourceTransportAddress(srcip);
2867         arpmatch.setArpTargetTransportAddress(dstip);
2868
2869         match.setEthernetMatch(ethmatch.build());
2870         match.setLayer3Match(arpmatch.build());
2871
2872         return match;
2873     }
2874
2875     private static MatchBuilder createL3IPv6Match() {
2876         final MatchBuilder match = new MatchBuilder();
2877
2878         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2879         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2880         ethTypeBuilder.setType(new EtherType(0x86ddL));
2881         eth.setEthernetType(ethTypeBuilder.build());
2882         match.setEthernetMatch(eth.build());
2883
2884         final MacAddress ndsll = new MacAddress("c2:00:54:f5:00:00");
2885         final MacAddress ndtll = new MacAddress("00:0c:29:0e:4c:67");
2886         final Ipv6ExtHeaderBuilder nextheader = new Ipv6ExtHeaderBuilder();
2887         nextheader.setIpv6Exthdr(58);
2888         final Ipv6LabelBuilder ipv6label = new Ipv6LabelBuilder();
2889         final Ipv6FlowLabel label = new Ipv6FlowLabel(10028L);
2890         ipv6label.setIpv6Flabel(label);
2891         ipv6label.setFlabelMask(new Ipv6FlowLabel(1L));
2892
2893         final Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder(); // icmpv6
2894         // match
2895         icmpv6match.setIcmpv6Type((short) 135);
2896         icmpv6match.setIcmpv6Code((short) 0);
2897         match.setIcmpv6Match(icmpv6match.build());
2898
2899         final Ipv6MatchBuilder ipv6match = new Ipv6MatchBuilder();
2900         // ipv6match.setIpv6Source(srcip6);
2901         // ipv6match.setIpv6Destination(dstip6);
2902         // ipv6match.setIpv6ExtHeader(nextheader.build());
2903         ipv6match.setIpv6NdSll(ndsll);
2904         ipv6match.setIpv6NdTll(ndtll);
2905         // ipv6match.setIpv6NdTarget(ndtarget);
2906         ipv6match.setIpv6Label(ipv6label.build());
2907
2908         match.setLayer3Match(ipv6match.build());
2909
2910         return match;
2911     }
2912
2913     private static MatchBuilder createICMPv4Match() {
2914         final MatchBuilder match = new MatchBuilder();
2915         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2916         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2917         ethTypeBuilder.setType(new EtherType(0x0800L));
2918         eth.setEthernetType(ethTypeBuilder.build());
2919         match.setEthernetMatch(eth.build());
2920
2921         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
2922         ipmatch.setIpProtocol((short) 1);
2923         match.setIpMatch(ipmatch.build());
2924
2925         final Icmpv4MatchBuilder icmpv4match = new Icmpv4MatchBuilder(); // icmpv4
2926         // match
2927         icmpv4match.setIcmpv4Type((short) 8);
2928         icmpv4match.setIcmpv4Code((short) 0);
2929         match.setIcmpv4Match(icmpv4match.build());
2930         return match;
2931     }
2932
2933     private static MatchBuilder createICMPv6Match() {
2934
2935         final MatchBuilder match = new MatchBuilder();
2936         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2937         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2938         ethTypeBuilder.setType(new EtherType(0x86ddL));
2939         eth.setEthernetType(ethTypeBuilder.build());
2940         match.setEthernetMatch(eth.build());
2941
2942         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
2943         ipmatch.setIpProtocol((short) 58);
2944         match.setIpMatch(ipmatch.build());
2945
2946         final Icmpv6MatchBuilder icmpv6match = new Icmpv6MatchBuilder(); // icmpv6
2947         // match
2948         icmpv6match.setIcmpv6Type((short) 135);
2949         icmpv6match.setIcmpv6Code((short) 1);
2950         match.setIcmpv6Match(icmpv6match.build());
2951
2952         return match;
2953     }
2954
2955     private static MatchBuilder createToSMatch() {
2956         final MatchBuilder match = new MatchBuilder();
2957         final EthernetMatchBuilder ethmatch = new EthernetMatchBuilder();
2958         final EthernetTypeBuilder ethtype = new EthernetTypeBuilder();
2959         final EtherType type = new EtherType(0x0800L);
2960         ethmatch.setEthernetType(ethtype.setType(type).build());
2961         match.setEthernetMatch(ethmatch.build());
2962
2963         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
2964         ipmatch.setIpProtocol((short) 6);
2965         final Dscp dscp = new Dscp((short) 8);
2966         ipmatch.setIpDscp(dscp);
2967         match.setIpMatch(ipmatch.build());
2968         return match;
2969     }
2970
2971     private static MatchBuilder createL4TCPMatch() {
2972         final MatchBuilder match = new MatchBuilder();
2973
2974         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2975         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2976         ethTypeBuilder.setType(new EtherType(0x0800L));
2977         eth.setEthernetType(ethTypeBuilder.build());
2978         match.setEthernetMatch(eth.build());
2979
2980         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
2981         ipmatch.setIpProtocol((short) 6);
2982         match.setIpMatch(ipmatch.build());
2983
2984         final PortNumber srcport = new PortNumber(1213);
2985         final PortNumber dstport = new PortNumber(646);
2986         final TcpMatchBuilder tcpmatch = new TcpMatchBuilder(); // tcp match
2987         tcpmatch.setTcpSourcePort(srcport);
2988         tcpmatch.setTcpDestinationPort(dstport);
2989         match.setLayer4Match(tcpmatch.build());
2990
2991         return match;
2992     }
2993
2994     private static MatchBuilder createL4UDPMatch() {
2995         final MatchBuilder match = new MatchBuilder();
2996
2997         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
2998         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
2999         ethTypeBuilder.setType(new EtherType(0x0800L));
3000         eth.setEthernetType(ethTypeBuilder.build());
3001         match.setEthernetMatch(eth.build());
3002
3003         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
3004         ipmatch.setIpProtocol((short) 17);
3005         match.setIpMatch(ipmatch.build());
3006
3007         final PortNumber srcport = new PortNumber(1325);
3008         final PortNumber dstport = new PortNumber(42);
3009         final UdpMatchBuilder udpmatch = new UdpMatchBuilder(); // udp match
3010         udpmatch.setUdpDestinationPort(dstport);
3011         udpmatch.setUdpSourcePort(srcport);
3012         match.setLayer4Match(udpmatch.build());
3013
3014         return match;
3015     }
3016
3017     private static MatchBuilder createL4SCTPMatch() {
3018         final MatchBuilder match = new MatchBuilder();
3019
3020         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
3021         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
3022         ethTypeBuilder.setType(new EtherType(0x0800L));
3023         eth.setEthernetType(ethTypeBuilder.build());
3024         match.setEthernetMatch(eth.build());
3025
3026         final IpMatchBuilder ipmatch = new IpMatchBuilder(); // ipv4 version
3027         ipmatch.setIpProtocol((short) 132);
3028         match.setIpMatch(ipmatch.build());
3029
3030         final SctpMatchBuilder sctpmatch = new SctpMatchBuilder();
3031         final PortNumber srcport = new PortNumber(1435);
3032         final PortNumber dstport = new PortNumber(22);
3033         sctpmatch.setSctpSourcePort(srcport);
3034         sctpmatch.setSctpDestinationPort(dstport);
3035         match.setLayer4Match(sctpmatch.build());
3036
3037         return match;
3038     }
3039
3040     private static MatchBuilder createMetadataMatch() {
3041         final MatchBuilder match = new MatchBuilder();
3042         final byte[] metamask = new byte[]{(byte) -1, (byte) -1, (byte) -1, 0, 0, 0, (byte) 1, (byte) 1};
3043         final MetadataBuilder metadata = new MetadataBuilder(); // metadata match
3044         metadata.setMetadata(BigInteger.valueOf(500L));
3045         metadata.setMetadataMask(new BigInteger(1, metamask));
3046         match.setMetadata(metadata.build());
3047
3048         return match;
3049     }
3050
3051     private static MatchBuilder createMplsMatch() {
3052         final MatchBuilder match = new MatchBuilder();
3053
3054         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
3055         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
3056         ethTypeBuilder.setType(new EtherType(0x8847L));
3057         eth.setEthernetType(ethTypeBuilder.build());
3058         match.setEthernetMatch(eth.build());
3059
3060         final ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder(); // mpls
3061         // match
3062         protomatch.setMplsLabel((long) 36008);
3063         protomatch.setMplsTc((short) 4);
3064         protomatch.setMplsBos((short) 1);
3065         match.setProtocolMatchFields(protomatch.build());
3066
3067         return match;
3068
3069     }
3070
3071     private static MatchBuilder createPbbMatch() {
3072         final MatchBuilder match = new MatchBuilder();
3073
3074         final EthernetMatchBuilder eth = new EthernetMatchBuilder();
3075         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
3076         ethTypeBuilder.setType(new EtherType(0x88E7L));
3077         eth.setEthernetType(ethTypeBuilder.build());
3078         match.setEthernetMatch(eth.build());
3079
3080         final ProtocolMatchFieldsBuilder protomatch = new ProtocolMatchFieldsBuilder(); // mpls
3081         // match
3082         protomatch.setPbb(new PbbBuilder().setPbbIsid(4L).setPbbMask(
3083                 new BigInteger(new byte[]{0, 1, 0, 0}).longValue()).build());
3084         match.setProtocolMatchFields(protomatch.build());
3085
3086         return match;
3087
3088     }
3089
3090     private static MatchBuilder createTunnelIDMatch() {
3091         final MatchBuilder match = new MatchBuilder();
3092         final TunnelBuilder tunnel = new TunnelBuilder(); // tunnel id match
3093         tunnel.setTunnelId(BigInteger.valueOf(10668));
3094         final byte[] mask = new byte[]{(byte) -1, (byte) -1, (byte) -1, 0, 0, 0, (byte) 1, (byte) 1};
3095         tunnel.setTunnelMask(new BigInteger(1, mask));
3096         match.setTunnel(tunnel.build());
3097
3098         return match;
3099     }
3100
3101     /**
3102      * Test match for TCP_Flags.
3103      *
3104      * @return match containing Ethertype (0x0800), IP Protocol (TCP), TCP_Flag (SYN)
3105      */
3106     //FIXME: move to extensible support
3107     private static MatchBuilder createTcpFlagMatch() {
3108         final MatchBuilder match = new MatchBuilder();
3109
3110         // Ethertype match
3111         final EthernetMatchBuilder ethernetType = new EthernetMatchBuilder();
3112         final EthernetTypeBuilder ethTypeBuilder = new EthernetTypeBuilder();
3113         ethTypeBuilder.setType(new EtherType(0x0800L));
3114         ethernetType.setEthernetType(ethTypeBuilder.build());
3115         match.setEthernetMatch(ethernetType.build());
3116
3117         // TCP Protocol Match
3118         final IpMatchBuilder ipMatch = new IpMatchBuilder(); // ipv4 version
3119         ipMatch.setIpProtocol((short) 6);
3120         match.setIpMatch(ipMatch.build());
3121
3122         // TCP Port Match
3123         final PortNumber dstPort = new PortNumber(80);
3124         final TcpMatchBuilder tcpMatch = new TcpMatchBuilder();
3125         tcpMatch.setTcpDestinationPort(dstPort);
3126         match.setLayer4Match(tcpMatch.build());
3127         /**
3128          * Defined TCP Flag values in OVS v2.1+
3129          * TCP_FIN 0x001 / TCP_SYN 0x002 / TCP_RST 0x004
3130          * TCP_PSH 0x008 / TCP_ACK 0x010 / TCP_URG 0x020
3131          * TCP_ECE 0x040 / TCP_CWR 0x080 / TCP_NS  0x100
3132          */
3133         final TcpFlagsMatchBuilder tcpFlagsMatch = new TcpFlagsMatchBuilder();
3134         tcpFlagsMatch.setTcpFlags(0x002);
3135         match.setTcpFlagsMatch(tcpFlagsMatch.build());
3136
3137         return match;
3138     }
3139
3140     public void _removeMDFlow(final CommandInterpreter ci) {
3141         final ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
3142         final NodeBuilder tn = createTestNode(ci.nextArgument());
3143         final String flowtype = ci.nextArgument();
3144         FlowBuilder tf;
3145         if (flowtype.equals("fTM")) {
3146             tf = createtablemiss();
3147         } else {
3148             tf = createTestFlow(tn, flowtype, ci.nextArgument());
3149         }
3150         final InstanceIdentifier<Flow> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, tn.getKey())
3151                 .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf.getTableId()))
3152                 .child(Flow.class, tf.getKey());
3153         modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
3154         final ListenableFuture<Void> commitFuture = modification.submit();
3155         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
3156             @Override
3157             public void onSuccess(final Void notUsed) {
3158                 ci.println("Status of Group Data Loaded Transaction: success.");
3159             }
3160
3161             @Override
3162             public void onFailure(final Throwable throwable) {
3163                 LOG.error(throwable.getMessage(), throwable);
3164                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
3165             }
3166         }, MoreExecutors.directExecutor());
3167     }
3168
3169     /**
3170      * Adds a flow.
3171      *
3172      * @param ci arguments: switchId flowType tableNum, e.g.: addMDFlow openflow:1 f1 42
3173      */
3174     public void _addMDFlow(final CommandInterpreter ci) {
3175         final NodeBuilder tn = createTestNode(ci.nextArgument());
3176         final String flowtype = ci.nextArgument();
3177         FlowBuilder tf;
3178         if (flowtype.equals("fTM")) {
3179             tf = createtablemiss();
3180         } else {
3181             tf = createTestFlow(tn, flowtype, ci.nextArgument());
3182         }
3183         writeFlow(ci, tf, tn);
3184     }
3185
3186     private void writeFlow(final CommandInterpreter ci, final FlowBuilder flow, final NodeBuilder nodeBuilder) {
3187         final ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
3188         final InstanceIdentifier<Flow> path1 = InstanceIdentifier.create(Nodes.class)
3189                 .child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class)
3190                 .child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flow.getKey());
3191         modification.merge(LogicalDatastoreType.CONFIGURATION,
3192                 nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
3193         modification.merge(LogicalDatastoreType.CONFIGURATION, path1, flow.build(), true);
3194         final ListenableFuture<Void> commitFuture = modification.submit();
3195         Futures.addCallback(commitFuture, new FutureCallback<Void>() {
3196             @Override
3197             public void onSuccess(final Void notUsed) {
3198                 ci.println("Status of Group Data Loaded Transaction: success.");
3199             }
3200
3201             @Override
3202             public void onFailure(final Throwable throwable) {
3203                 LOG.error(throwable.getMessage(), throwable);
3204                 ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
3205             }
3206         }, MoreExecutors.directExecutor());
3207     }
3208
3209     public void _modifyMDFlow(final CommandInterpreter ci) {
3210         final NodeBuilder tn = createTestNode(ci.nextArgument());
3211         final FlowBuilder tf = createTestFlow(tn, ci.nextArgument(), ci.nextArgument());
3212         tf.setFlowName(UPDATED_FLOW_NAME);
3213         writeFlow(ci, tf, tn);
3214         tf.setFlowName(ORIGINAL_FLOW_NAME);
3215         writeFlow(ci, tf, tn);
3216     }
3217
3218     @Override
3219     public String getHelp() {
3220         return "No help";
3221     }
3222
3223     /*
3224      * usage testSwitchFlows <numberOfSwitches> <numberOfFlows> <warmup iterations> <Number Of Threads>
3225      * ex: _perfFlowTest 10 5 1 2
3226      */
3227     public void _perfFlowTest(final CommandInterpreter ci) {
3228
3229         final String numberOfSwtichesStr = ci.nextArgument();
3230         final String numberOfFlowsStr = ci.nextArgument();
3231         final String warmupIterationsStr = ci.nextArgument();
3232         final String threadCountStr = ci.nextArgument();
3233         final String warmUpStr = ci.nextArgument();
3234
3235         int numberOfSwtiches = 0;
3236         int numberOfFlows = 0;
3237         int warmupIterations = 0;
3238         boolean warmUpIterations = false;
3239
3240         int threadCount = 0;
3241         if (numberOfSwtichesStr != null && !numberOfSwtichesStr.trim().equals("")) {
3242             numberOfSwtiches = Integer.parseInt(numberOfSwtichesStr);
3243         } else {
3244             numberOfSwtiches = 2;
3245         }
3246
3247         if (numberOfFlowsStr != null && !numberOfFlowsStr.trim().equals("")) {
3248             numberOfFlows = Integer.parseInt(numberOfFlowsStr);
3249         } else {
3250             numberOfFlows = 2;
3251         }
3252
3253         if (warmupIterationsStr != null && !warmupIterationsStr.trim().equals("")) {
3254             warmupIterations = Integer.parseInt(warmupIterationsStr);
3255         } else {
3256             warmupIterations = 2;
3257         }
3258
3259         if (threadCountStr != null && !threadCountStr.trim().equals("")) {
3260             threadCount = Integer.parseInt(threadCountStr);
3261         } else {
3262             threadCount = 2;
3263         }
3264         if (warmUpStr != null && !warmUpStr.trim().equals("") && warmUpStr.trim().equals("true")) {
3265             warmUpIterations = true;
3266         } else {
3267             warmUpIterations = false;
3268         }
3269         ci.println("*     Test Configurations*");
3270         ci.println("*     numberOfSwtiches:::" + numberOfSwtiches + "");
3271         ci.println("*     numberOfFlows:::" + numberOfFlows + "");
3272         ci.println("*     warmupIterations:::" + warmupIterations + "");
3273         ci.println("*     Number of Threads :::" + threadCount + "");
3274         ci.println("*     Warmup Required? :::" + warmUpIterations + "");
3275
3276         String dataPath = "openflow:1";
3277         NodeBuilder tn;
3278         FlowBuilder tf;
3279         final String tableId = "0";
3280         if (warmUpIterations) {
3281             ci.println("----Warmup Started-----");
3282             for (int j = 1; j <= warmupIterations; j++) {
3283                 for (int i = 1; i <= numberOfSwtiches; i++) {
3284                     dataPath = "openflow:" + i;
3285                     tn = createTestNode(dataPath);
3286                     for (int flow = 1; flow < numberOfFlows; flow++) {
3287                         tf = createTestFlowPerfTest("f1", tableId, flow);
3288                         writeFlow(ci, tf, tn);
3289                     }
3290                 }
3291             }
3292
3293             ci.println("----Warmup Done-----");
3294         }
3295         try {
3296             final ExecutorService executor = Executors.newFixedThreadPool(threadCount);
3297             int tableID = 0;
3298             for (int t = 0; t < threadCount; t++) {
3299                 tableID = t + 1;
3300                 final Runnable tRunnable = new TestFlowThread(numberOfSwtiches, numberOfFlows, ci, t, tableID);
3301                 executor.execute(tRunnable);
3302             }
3303             executor.shutdown();
3304             executor.awaitTermination(1, TimeUnit.SECONDS);
3305         } catch (InterruptedException e) {
3306             ci.println("Exception:" + e.getMessage());
3307         }
3308     }
3309
3310     public class TestFlowThread implements Runnable {
3311
3312         int numberOfSwitches;
3313         int numberOfFlows;
3314         CommandInterpreter ci;
3315         int theadNumber;
3316         int tableID = 0;
3317
3318         TestFlowThread(final int numberOfSwtiches, final int numberOfFlows, final CommandInterpreter ci,
3319                 final int threadNumber, final int tableID) {
3320             this.numberOfSwitches = numberOfSwtiches;
3321             this.numberOfFlows = numberOfFlows;
3322             this.ci = ci;
3323             this.theadNumber = threadNumber;
3324             this.tableID = tableID;
3325         }
3326
3327         @Override
3328         public void run() {
3329             executeFlow();
3330         }
3331
3332         public void executeFlow() {
3333
3334             String dataPath = "openflow:1";
3335             NodeBuilder tn;
3336             FlowBuilder tf;
3337             //String tableId = "0";
3338
3339             ci.println("New Thread started with id:  ID_"
3340                     + this.theadNumber);
3341             int totalNumberOfFlows = 0;
3342             final long startTime = System.currentTimeMillis();
3343
3344             for (int i = 1; i <= this.numberOfSwitches; i++) {
3345                 dataPath = "openflow:" + i;
3346                 tn = createTestNode(dataPath);
3347                 for (int flow2 = 1; flow2 <= this.numberOfFlows; flow2++) {
3348                     tf = createTestFlowPerfTest("f1", "" + this.tableID, flow2);
3349                     writeFlow(this.ci, tf, tn);
3350                     totalNumberOfFlows++;
3351                 }
3352             }
3353             final long endTime = System.currentTimeMillis();
3354             final long timeInSeconds = Math.round((endTime - startTime) / 1000.0F);
3355             if (timeInSeconds > 0) {
3356                 ci.println("Total flows added in Thread:" + this.theadNumber + ": Flows/Sec::"
3357                     + Math.round((float)totalNumberOfFlows / timeInSeconds));
3358             } else {
3359                 ci.println("Total flows added in Thread:" + this.theadNumber + ": Flows/Sec::" + totalNumberOfFlows);
3360             }
3361         }
3362
3363     }
3364
3365     /*
3366      * usage testAllFlows <dp>
3367      * ex: _perfFlowTest 1
3368      */
3369     @SuppressWarnings("checkstyle:IllegalCatch")
3370     public void _testAllFlows(final CommandInterpreter ci) {
3371         String dataPathID = ci.nextArgument();
3372         final int numberOfFlows = 82;
3373         if (dataPathID == null || dataPathID.trim().equals("")) {
3374             dataPathID = "1";
3375         }
3376         ci.println("*     Test All Flows    *");
3377         ci.println("*     dataPathID:::" + dataPathID + "");
3378         final String dataPath = "openflow:" + dataPathID;
3379         final String tableId = "0";
3380         final NodeBuilder tn = createTestNode(dataPath);
3381         FlowBuilder tf;
3382         for (int flow = 1; flow < numberOfFlows; flow++) {
3383             final String flowID = "f" + flow;
3384             try {
3385                 tf = createTestFlow(tn, flowID, tableId);
3386                 writeFlow(ci, tf, tn);
3387             } catch (RuntimeException e) {
3388                 ci.println("--Test Failed--Issue found while adding flow" + flow);
3389                 break;
3390             }
3391         }
3392     }
3393 }