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