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