CORD-389 Fix for Accton 6712 deployment

Related to this topic:
- Disable the meter collector since right now it is not supported
- Implement extension VLAN ID selector/treatment for OFDPA
    Since it requires two special flow entries to match untagged packets
        0x1ffe/no mask (filtering rule, need to go first)
        0x0000/0x1fff setvid 0x0ffe (assignment rule, need to go second)
- Not able to point /32 IP address to ECMP group. Use /31 instead.

In addition:
- Implement serializer for ExtensionCriterion

Change-Id: I621b3ad14014d7e6945c014cdae4f7cd2939288e

@@ -230,6 +230,13 @@ public class RoutingRulePopulator {
     public boolean populateIpRuleForRouter(DeviceId deviceId,
                                            IpPrefix ipPrefix, DeviceId destSw,
                                            Set<DeviceId> nextHops) {
+        // TODO: OFDPA does not support /32 with ECMP group at this moment.
+        //       Use /31 instead
+        IpPrefix effectivePrefix =
+                (ipPrefix.prefixLength() == IpPrefix.MAX_INET_MASK_LENGTH) ?
+                        IpPrefix.valueOf(ipPrefix.getIp4Prefix().address(), 31) :
+                        ipPrefix;
+
         int segmentId;
         try {
             segmentId = config.getSegmentId(destSw);
@@ -239,7 +246,7 @@ public class RoutingRulePopulator {
         }
 
         TrafficSelector.Builder sbuilder = DefaultTrafficSelector.builder();
-        sbuilder.matchIPDst(ipPrefix);
+        sbuilder.matchIPDst(effectivePrefix);
         sbuilder.matchEthType(Ethernet.TYPE_IPV4);
         TrafficSelector selector = sbuilder.build();
 
@@ -277,7 +284,7 @@ public class RoutingRulePopulator {
                 .makePermanent()
                 .nextStep(nextId)
                 .withSelector(selector)
-                .withPriority(2000 * ipPrefix.prefixLength())
+                .withPriority(2000 * effectivePrefix.prefixLength())
                 .withFlag(ForwardingObjective.Flag.SPECIFIC);
         if (treatment != null) {
             fwdBuilder.withTreatment(treatment);

@@ -615,9 +615,9 @@ public final class Criteria {
      *
      * @param extensionSelector extension selector
      * @param deviceId device ID
-     * @return match criterion
+     * @return match extension criterion
      */
-    public static Criterion extension(ExtensionSelector extensionSelector,
+    public static ExtensionCriterion extension(ExtensionSelector extensionSelector,
                                       DeviceId deviceId) {
         return new ExtensionCriterion(extensionSelector, deviceId);
     }

@@ -37,8 +37,8 @@ public class ExtensionSelectorType {
         NICIRA_MATCH_NSH_CH1(2),
         NICIRA_MATCH_NSH_CH2(3),
         NICIRA_MATCH_NSH_CH3(4),
-        NICIRA_MATCH_NSH_CH4(5);
-
+        NICIRA_MATCH_NSH_CH4(5),
+        OFDPA_MATCH_VLAN_VID(16);
 
         private ExtensionSelectorType type;
 

@@ -34,6 +34,10 @@ public final class ExtensionTreatmentType {
     public enum ExtensionTreatmentTypes {
         NICIRA_SET_TUNNEL_DST(0),
         NICIRA_RESUBMIT(1),
+        NICIRA_MOV_ARP_SHA_TO_THA(2),
+        NICIRA_MOV_ARP_SPA_TO_TPA(3),
+        NICIRA_MOV_ETH_SRC_TO_DST(4),
+        NICIRA_MOV_IP_SRC_TO_DST(5),
         NICIRA_RESUBMIT_TABLE(14),
         NICIRA_SET_NSH_SPI(32),
         NICIRA_SET_NSH_SI(33),
@@ -41,10 +45,7 @@ public final class ExtensionTreatmentType {
         NICIRA_SET_NSH_CH2(35),
         NICIRA_SET_NSH_CH3(36),
         NICIRA_SET_NSH_CH4(37),
-        NICIRA_MOV_ARP_SHA_TO_THA(2),
-        NICIRA_MOV_ARP_SPA_TO_TPA(3),
-        NICIRA_MOV_ETH_SRC_TO_DST(4),
-        NICIRA_MOV_IP_SRC_TO_DST(5);
+        OFDPA_SET_VLAN_ID(64);
 
         private ExtensionTreatmentType type;
 

+/*
+ * Copyright 2015-2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.store.serializers;
+
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.Serializer;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+import org.onlab.osgi.DefaultServiceDirectory;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.behaviour.ExtensionSelectorResolver;
+import org.onosproject.net.driver.DefaultDriverData;
+import org.onosproject.net.driver.DefaultDriverHandler;
+import org.onosproject.net.driver.DriverHandler;
+import org.onosproject.net.driver.DriverService;
+import org.onosproject.net.flow.criteria.Criteria;
+import org.onosproject.net.flow.criteria.ExtensionCriterion;
+import org.onosproject.net.flow.criteria.ExtensionSelector;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType;
+
+/**
+ * Serializer for extension criteria.
+ */
+public class ExtensionCriterionSerializer extends Serializer<ExtensionCriterion> {
+
+    /**
+     * Constructs a extension criterion serializer.
+     */
+    public ExtensionCriterionSerializer() {
+        super(false, true);
+    }
+
+    @Override
+    public void write(Kryo kryo, Output output, ExtensionCriterion object) {
+        kryo.writeClassAndObject(output, object.extensionSelector().type());
+        kryo.writeClassAndObject(output, object.deviceId());
+        kryo.writeClassAndObject(output, object.extensionSelector().serialize());
+    }
+
+    @Override
+    public ExtensionCriterion read(Kryo kryo, Input input,
+            Class<ExtensionCriterion> type) {
+        ExtensionSelectorType exType = (ExtensionSelectorType) kryo.readClassAndObject(input);
+        DeviceId deviceId = (DeviceId) kryo.readClassAndObject(input);
+
+        DriverService driverService = DefaultServiceDirectory.getService(DriverService.class);
+        DriverHandler handler = new DefaultDriverHandler(
+                new DefaultDriverData(driverService.getDriver(deviceId), deviceId));
+
+        ExtensionSelectorResolver resolver = handler.behaviour(ExtensionSelectorResolver.class);
+        ExtensionSelector selector = resolver.getExtensionSelector(exType);
+
+        byte[] bytes = (byte[]) kryo.readClassAndObject(input);
+        selector.deserialize(bytes);
+        return Criteria.extension(selector, deviceId);
+    }
+}

 /*
- * Copyright 2015 Open Networking Laboratory
+ * Copyright 2015-2016 Open Networking Laboratory
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,11 +32,14 @@ import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
 import org.onosproject.net.flow.instructions.Instructions;
 
 /**
- * Created by jono on 10/29/15.
+ * Serializer for extension instructions.
  */
 public class ExtensionInstructionSerializer extends
         Serializer<Instructions.ExtensionInstructionWrapper> {
 
+    /**
+     * Constructs a extension instruction serializer.
+     */
     public ExtensionInstructionSerializer() {
         super(false, true);
     }
@@ -45,9 +48,7 @@ public class ExtensionInstructionSerializer extends
     public void write(Kryo kryo, Output output, Instructions.ExtensionInstructionWrapper object) {
         kryo.writeClassAndObject(output, object.extensionInstruction().type());
         kryo.writeClassAndObject(output, object.deviceId());
-
         kryo.writeClassAndObject(output, object.extensionInstruction().serialize());
-
     }
 
     @Override
@@ -61,7 +62,6 @@ public class ExtensionInstructionSerializer extends
                 new DefaultDriverData(driverService.getDriver(deviceId), deviceId));
 
         ExtensionTreatmentResolver resolver = handler.behaviour(ExtensionTreatmentResolver.class);
-
         ExtensionTreatment instruction = resolver.getExtensionInstruction(exType);
 
         byte[] bytes = (byte[]) kryo.readClassAndObject(input);

@@ -108,6 +108,8 @@ import org.onosproject.net.flow.criteria.ArpPaCriterion;
 import org.onosproject.net.flow.criteria.Criterion;
 import org.onosproject.net.flow.criteria.EthCriterion;
 import org.onosproject.net.flow.criteria.EthTypeCriterion;
+import org.onosproject.net.flow.criteria.ExtensionCriterion;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType;
 import org.onosproject.net.flow.criteria.IPCriterion;
 import org.onosproject.net.flow.criteria.IPDscpCriterion;
 import org.onosproject.net.flow.criteria.IPEcnCriterion;
@@ -482,6 +484,8 @@ public final class KryoNamespaces {
             .register(new DefaultOutboundPacketSerializer(), DefaultOutboundPacket.class)
             .register(new AnnotationsSerializer(), DefaultAnnotations.class)
             .register(new ExtensionInstructionSerializer(), Instructions.ExtensionInstructionWrapper.class)
+            .register(new ExtensionCriterionSerializer(), ExtensionCriterion.class)
+            .register(ExtensionSelectorType.class)
             .register(ExtensionTreatmentType.class)
             .register(Versioned.class)
             .register(MapEvent.class)

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.driver.extensions;
+
+import org.onlab.packet.VlanId;
+import org.onosproject.net.behaviour.ExtensionSelectorResolver;
+import org.onosproject.net.driver.AbstractHandlerBehaviour;
+import org.onosproject.net.flow.criteria.ExtensionSelector;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType.ExtensionSelectorTypes;
+import org.onosproject.openflow.controller.ExtensionSelectorInterpreter;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.match.MatchField;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxmVlanVid;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxmVlanVidMasked;
+import org.projectfloodlight.openflow.types.OFVlanVidMatch;
+import org.projectfloodlight.openflow.types.VlanVid;
+
+/**
+ * Interpreter for OFDPA OpenFlow selector extensions.
+ */
+public class OfdpaExtensionSelectorInterpreter extends AbstractHandlerBehaviour
+        implements ExtensionSelectorInterpreter, ExtensionSelectorResolver {
+
+    @Override
+    public boolean supported(ExtensionSelectorType extensionSelectorType) {
+        if (extensionSelectorType.equals(ExtensionSelectorTypes.OFDPA_MATCH_VLAN_VID.type())) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public OFOxm<?> mapSelector(OFFactory factory, ExtensionSelector extensionSelector) {
+        ExtensionSelectorType type = extensionSelector.type();
+        if (type.equals(ExtensionSelectorType.ExtensionSelectorTypes.OFDPA_MATCH_VLAN_VID.type())) {
+            VlanId vlanId = ((OfdpaMatchVlanVid) extensionSelector).vlanId();
+            // Special VLAN 0x0000/0x1FFF required by OFDPA
+            if (vlanId.toShort() == 0x0000) {
+                OFVlanVidMatch vid = OFVlanVidMatch.ofRawVid(vlanId.toShort());
+                OFVlanVidMatch mask = OFVlanVidMatch.ofRawVid((short) 0x1FFF);
+                return factory.oxms().vlanVidMasked(vid, mask);
+            // Normal case
+            } else if (vlanId.equals(VlanId.ANY)) {
+                return factory.oxms().vlanVidMasked(OFVlanVidMatch.PRESENT, OFVlanVidMatch.PRESENT);
+            } else if (vlanId.equals(VlanId.NONE)) {
+                return factory.oxms().vlanVid(OFVlanVidMatch.NONE);
+            } else {
+                return factory.oxms().vlanVid(OFVlanVidMatch.ofVlanVid(VlanVid.ofVlan(vlanId.toShort())));
+            }
+        }
+        throw new UnsupportedOperationException(
+                "Unexpected ExtensionSelector: " + extensionSelector.toString());
+    }
+
+    @Override
+    public ExtensionSelector mapOxm(OFOxm<?> oxm) {
+        VlanId vlanId;
+
+        if (oxm.getMatchField().equals(MatchField.VLAN_VID)) {
+            if (oxm.isMasked()) {
+                OFVlanVidMatch vid = ((OFOxmVlanVidMasked) oxm).getValue();
+                OFVlanVidMatch mask = ((OFOxmVlanVidMasked) oxm).getMask();
+
+                if (vid.equals(OFVlanVidMatch.ofRawVid((short) 0))) {
+                    vlanId = VlanId.vlanId((short) 0);
+                } else if (vid.equals(OFVlanVidMatch.PRESENT) &&
+                        mask.equals(OFVlanVidMatch.PRESENT)) {
+                    vlanId = VlanId.ANY;
+                } else {
+                    vlanId = VlanId.vlanId(vid.getVlan());
+                }
+            } else {
+                OFVlanVidMatch vid = ((OFOxmVlanVid) oxm).getValue();
+
+                if (!vid.isPresentBitSet()) {
+                    vlanId = VlanId.NONE;
+                } else {
+                    vlanId = VlanId.vlanId(vid.getVlan());
+                }
+            }
+            return new OfdpaMatchVlanVid(vlanId);
+        }
+        throw new UnsupportedOperationException(
+                "Unexpected OXM: " + oxm.toString());
+    }
+
+    @Override
+    public ExtensionSelector getExtensionSelector(ExtensionSelectorType type) {
+        if (type.equals(ExtensionSelectorType.ExtensionSelectorTypes.OFDPA_MATCH_VLAN_VID.type())) {
+            return new OfdpaMatchVlanVid();
+        }
+        throw new UnsupportedOperationException(
+                "Driver does not support extension type " + type.toString());
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.driver.extensions;
+
+import org.onlab.packet.VlanId;
+import org.onosproject.net.behaviour.ExtensionTreatmentResolver;
+import org.onosproject.net.driver.AbstractHandlerBehaviour;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+import org.onosproject.openflow.controller.ExtensionTreatmentInterpreter;
+import org.projectfloodlight.openflow.protocol.OFActionType;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.action.OFAction;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetField;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxmVlanVid;
+import org.projectfloodlight.openflow.types.OFVlanVidMatch;
+
+/**
+ * Interpreter for OFDPA OpenFlow treatment extensions.
+ */
+public class OfdpaExtensionTreatmentInterpreter  extends AbstractHandlerBehaviour
+        implements ExtensionTreatmentInterpreter, ExtensionTreatmentResolver {
+    @Override
+    public boolean supported(ExtensionTreatmentType extensionTreatmentType) {
+        if (extensionTreatmentType.equals(
+                ExtensionTreatmentType.ExtensionTreatmentTypes.OFDPA_SET_VLAN_ID.type())) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public OFAction mapInstruction(OFFactory factory, ExtensionTreatment extensionTreatment) {
+        ExtensionTreatmentType type = extensionTreatment.type();
+        if (type.equals(ExtensionTreatmentType.ExtensionTreatmentTypes.OFDPA_SET_VLAN_ID.type())) {
+            VlanId vlanId = ((OfdpaSetVlanVid) extensionTreatment).vlanId();
+            // NOTE: OFDPA requires isPresent bit set to zero.
+            OFVlanVidMatch match = OFVlanVidMatch.ofRawVid(vlanId.toShort());
+            return factory.actions().setField(factory.oxms().vlanVid(match));
+        }
+        throw new UnsupportedOperationException(
+                "Unexpected ExtensionTreatment: " + extensionTreatment.toString());
+    }
+
+    @Override
+    public ExtensionTreatment mapAction(OFAction action) {
+        if (action.getType().equals(OFActionType.SET_FIELD)) {
+            OFActionSetField setFieldAction = (OFActionSetField) action;
+            OFOxm<?> oxm = setFieldAction.getField();
+            switch (oxm.getMatchField().id) {
+                case VLAN_VID:
+                    OFOxmVlanVid vlanVid = (OFOxmVlanVid) oxm;
+                    return new OfdpaSetVlanVid(VlanId.vlanId(vlanVid.getValue().getRawVid()));
+                default:
+                    throw new UnsupportedOperationException(
+                            "Driver does not support extension type " + oxm.getMatchField().id);
+            }
+        }
+        throw new UnsupportedOperationException(
+                "Unexpected OFAction: " + action.toString());
+    }
+
+    @Override
+    public ExtensionTreatment getExtensionInstruction(ExtensionTreatmentType type) {
+        if (type.equals(ExtensionTreatmentType.ExtensionTreatmentTypes.OFDPA_SET_VLAN_ID.type())) {
+            return new OfdpaSetVlanVid();
+        }
+        throw new UnsupportedOperationException(
+                "Driver does not support extension type " + type.toString());
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.driver.extensions;
+
+import com.google.common.base.MoreObjects;
+import org.onlab.packet.VlanId;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.net.flow.AbstractExtension;
+import org.onosproject.net.flow.criteria.ExtensionSelector;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType;
+
+import java.util.Objects;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * OFDPA VLAN ID extension match.
+ */
+public class OfdpaMatchVlanVid extends AbstractExtension implements ExtensionSelector {
+    private VlanId vlanId;
+
+    private static final KryoNamespace APPKRYO = new KryoNamespace.Builder()
+            .register(VlanId.class)
+            .build();
+
+    /**
+     * OFDPA VLAN ID extension match.
+     */
+    protected OfdpaMatchVlanVid() {
+        vlanId = null;
+    }
+
+    /**
+     * Constructs a new VLAN ID match with given VLAN ID.
+     *
+     * @param vlanId VLAN ID
+     */
+    public OfdpaMatchVlanVid(VlanId vlanId) {
+        checkNotNull(vlanId);
+        this.vlanId = vlanId;
+    }
+
+    /**
+     * Gets the VLAN ID.
+     *
+     * @return VLAN ID
+     */
+    public VlanId vlanId() {
+        return vlanId;
+    }
+
+    @Override
+    public ExtensionSelectorType type() {
+        return ExtensionSelectorType.ExtensionSelectorTypes.OFDPA_MATCH_VLAN_VID.type();
+    }
+
+    @Override
+    public void deserialize(byte[] data) {
+        vlanId = APPKRYO.deserialize(data);
+    }
+
+    @Override
+    public byte[] serialize() {
+        return APPKRYO.serialize(vlanId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(vlanId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof OfdpaMatchVlanVid) {
+            OfdpaMatchVlanVid that = (OfdpaMatchVlanVid) obj;
+            return Objects.equals(vlanId, that.vlanId);
+
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("vlanId", vlanId)
+                .toString();
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.driver.extensions;
+
+import com.google.common.base.MoreObjects;
+import org.onlab.packet.VlanId;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.net.flow.AbstractExtension;
+import org.onosproject.net.flow.instructions.ExtensionTreatment;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType;
+
+import java.util.Objects;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * OFDPA set VLAN ID extension instruction.
+ */
+public class OfdpaSetVlanVid extends AbstractExtension implements ExtensionTreatment {
+    private VlanId vlanId;
+
+    private static final KryoNamespace APPKRYO = new KryoNamespace.Builder()
+            .register(VlanId.class)
+            .build();
+
+    /**
+     * Constructs a new set VLAN ID instruction.
+     */
+    protected OfdpaSetVlanVid() {
+        vlanId = null;
+    }
+
+    /**
+     * Constructs a new set VLAN ID instruction with given VLAN ID.
+     *
+     * @param vlanId VLAN ID
+     */
+    public OfdpaSetVlanVid(VlanId vlanId) {
+        checkNotNull(vlanId);
+        this.vlanId = vlanId;
+    }
+
+    /**
+     * Gets the VLAN ID.
+     *
+     * @return VLAN ID
+     */
+    public VlanId vlanId() {
+        return vlanId;
+    }
+
+    @Override
+    public ExtensionTreatmentType type() {
+        return ExtensionTreatmentType.ExtensionTreatmentTypes.OFDPA_SET_VLAN_ID.type();
+    }
+
+    @Override
+    public void deserialize(byte[] data) {
+        vlanId = APPKRYO.deserialize(data);
+    }
+
+    @Override
+    public byte[] serialize() {
+        return APPKRYO.serialize(vlanId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(vlanId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof OfdpaSetVlanVid) {
+            OfdpaSetVlanVid that = (OfdpaSetVlanVid) obj;
+            return Objects.equals(vlanId, that.vlanId);
+
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("vlanId", vlanId)
+                .toString();
+    }
+}

@@ -92,6 +92,14 @@
             manufacturer="Broadcom Corp." hwVersion="OF-DPA.*" swVersion="OF-DPA.*">
         <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                    impl="org.onosproject.driver.pipeline.OFDPA2Pipeline"/>
+        <behaviour api="org.onosproject.openflow.controller.ExtensionTreatmentInterpreter"
+                   impl="org.onosproject.driver.extensions.OfdpaExtensionTreatmentInterpreter" />
+        <behaviour api="org.onosproject.net.behaviour.ExtensionTreatmentResolver"
+                   impl="org.onosproject.driver.extensions.OfdpaExtensionTreatmentInterpreter" />
+        <behaviour api="org.onosproject.openflow.controller.ExtensionSelectorInterpreter"
+                   impl="org.onosproject.driver.extensions.OfdpaExtensionSelectorInterpreter" />
+        <behaviour api="org.onosproject.net.behaviour.ExtensionSelectorResolver"
+                   impl="org.onosproject.driver.extensions.OfdpaExtensionSelectorInterpreter" />
     </driver>
     <driver name="pmc-olt" extends="default"
             manufacturer="PMC GPON Networks" hwVersion="PASffffffff v-1" swVersion="vOLT.*">

@@ -43,7 +43,7 @@ public interface ExtensionSelectorInterpreter extends HandlerBehaviour {
      *
      * @param factory OpenFlow factory
      * @param extensionSelector extension selector
-     * @return OpenFlow action
+     * @return OpenFlow OXM
      */
     OFOxm<?> mapSelector(OFFactory factory, ExtensionSelector extensionSelector);
 

@@ -43,12 +43,16 @@ import org.onosproject.net.flow.FlowEntry.FlowEntryState;
 import org.onosproject.net.flow.FlowRule;
 import org.onosproject.net.flow.TrafficSelector;
 import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.ExtensionSelectorType.ExtensionSelectorTypes;
+import org.onosproject.net.flow.instructions.ExtensionTreatmentType.ExtensionTreatmentTypes;
 import org.onosproject.net.flow.instructions.Instructions;
 import org.onosproject.openflow.controller.Dpid;
+import org.onosproject.openflow.controller.ExtensionSelectorInterpreter;
 import org.onosproject.openflow.controller.ExtensionTreatmentInterpreter;
 import org.projectfloodlight.openflow.protocol.OFFlowMod;
 import org.projectfloodlight.openflow.protocol.OFFlowRemoved;
 import org.projectfloodlight.openflow.protocol.OFFlowStatsEntry;
+import org.projectfloodlight.openflow.protocol.OFMatchV3;
 import org.projectfloodlight.openflow.protocol.OFVersion;
 import org.projectfloodlight.openflow.protocol.action.OFAction;
 import org.projectfloodlight.openflow.protocol.action.OFActionCircuit;
@@ -137,7 +141,6 @@ public class FlowEntryBuilder {
     public FlowEntryBuilder(Dpid dpid, OFFlowRemoved removed, DriverService driverService) {
         this.match = removed.getMatch();
         this.removed = removed;
-
         this.dpid = dpid;
         this.instructions = null;
         this.stat = null;
@@ -288,6 +291,14 @@ public class FlowEntryBuilder {
 
     private TrafficTreatment.Builder buildActions(List<OFAction> actions,
                                                   TrafficTreatment.Builder builder) {
+        DriverHandler driverHandler = getDriver(dpid);
+        ExtensionTreatmentInterpreter treatmentInterpreter;
+        if (driverHandler.hasBehaviour(ExtensionTreatmentInterpreter.class)) {
+            treatmentInterpreter = driverHandler.behaviour(ExtensionTreatmentInterpreter.class);
+        } else {
+            treatmentInterpreter = null;
+        }
+
         for (OFAction act : actions) {
             switch (act.getType()) {
                 case OUTPUT:
@@ -312,7 +323,6 @@ public class FlowEntryBuilder {
                     OFActionSetDlSrc dlsrc = (OFActionSetDlSrc) act;
                     builder.setEthSrc(
                             MacAddress.valueOf(dlsrc.getDlAddr().getLong()));
-
                     break;
                 case SET_NW_DST:
                     OFActionSetNwDst nwdst = (OFActionSetNwDst) act;
@@ -332,11 +342,8 @@ public class FlowEntryBuilder {
                         short lambda = ((OFOxmOchSigidBasic) ct.getField()).getValue().getChannelNumber();
                         builder.add(Instructions.modL0Lambda(Lambda.indexedLambda(lambda)));
                     }  else if (exp.getExperimenter() == 0x2320) {
-                        DriverHandler driver = getDriver(dpid);
-                        ExtensionTreatmentInterpreter interpreter = driver
-                                .behaviour(ExtensionTreatmentInterpreter.class);
-                        if (interpreter != null) {
-                            builder.extension(interpreter.mapAction(exp),
+                        if (treatmentInterpreter != null) {
+                            builder.extension(treatmentInterpreter.mapAction(exp),
                                               DeviceId.deviceId(Dpid.uri(dpid)));
                         }
                     } else {
@@ -405,6 +412,14 @@ public class FlowEntryBuilder {
 
 
     private void handleSetField(TrafficTreatment.Builder builder, OFActionSetField action) {
+        DriverHandler driverHandler = getDriver(dpid);
+        ExtensionTreatmentInterpreter treatmentInterpreter;
+        if (driverHandler.hasBehaviour(ExtensionTreatmentInterpreter.class)) {
+            treatmentInterpreter = driverHandler.behaviour(ExtensionTreatmentInterpreter.class);
+        } else {
+            treatmentInterpreter = null;
+        }
+
         OFOxm<?> oxm = action.getField();
         switch (oxm.getMatchField().id) {
         case VLAN_PCP:
@@ -413,9 +428,15 @@ public class FlowEntryBuilder {
             builder.setVlanPcp(vlanpcp.getValue().getValue());
             break;
         case VLAN_VID:
-            @SuppressWarnings("unchecked")
-            OFOxm<OFVlanVidMatch> vlanvid = (OFOxm<OFVlanVidMatch>) oxm;
-            builder.setVlanId(VlanId.vlanId(vlanvid.getValue().getVlan()));
+            if (treatmentInterpreter != null &&
+                    treatmentInterpreter.supported(ExtensionTreatmentTypes.OFDPA_SET_VLAN_ID.type())) {
+                builder.extension(treatmentInterpreter.mapAction(action),
+                        DeviceId.deviceId(Dpid.uri(dpid)));
+            } else {
+                @SuppressWarnings("unchecked")
+                OFOxm<OFVlanVidMatch> vlanvid = (OFOxm<OFVlanVidMatch>) oxm;
+                builder.setVlanId(VlanId.vlanId(vlanvid.getValue().getVlan()));
+            }
             break;
         case ETH_DST:
             @SuppressWarnings("unchecked")
@@ -475,10 +496,9 @@ public class FlowEntryBuilder {
             builder.setUdpSrc(TpPort.tpPort(udpsrc.getValue().getPort()));
             break;
         case TUNNEL_IPV4_DST:
-            DriverHandler driver = getDriver(dpid);
-            ExtensionTreatmentInterpreter interpreter = driver.behaviour(ExtensionTreatmentInterpreter.class);
-            if (interpreter != null) {
-                builder.extension(interpreter.mapAction(action), DeviceId.deviceId(Dpid.uri(dpid)));
+            if (treatmentInterpreter != null &&
+                    treatmentInterpreter.supported(ExtensionTreatmentTypes.NICIRA_SET_TUNNEL_DST.type())) {
+                builder.extension(treatmentInterpreter.mapAction(action), DeviceId.deviceId(Dpid.uri(dpid)));
             }
             break;
        case EXP_ODU_SIG_ID:
@@ -567,6 +587,14 @@ public class FlowEntryBuilder {
         Ip6Prefix ip6Prefix;
         Ip4Address ip;
 
+        DriverHandler driverHandler = getDriver(dpid);
+        ExtensionSelectorInterpreter selectorInterpreter;
+        if (driverHandler.hasBehaviour(ExtensionSelectorInterpreter.class)) {
+            selectorInterpreter = driverHandler.behaviour(ExtensionSelectorInterpreter.class);
+        } else {
+            selectorInterpreter = null;
+        }
+
         TrafficSelector.Builder builder = DefaultTrafficSelector.builder();
         for (MatchField<?> field : match.getMatchFields()) {
             switch (field.id) {
@@ -596,22 +624,33 @@ public class FlowEntryBuilder {
                 builder.matchEthType((short) ethType);
                 break;
             case VLAN_VID:
-                VlanId vlanId = null;
-                if (match.isPartiallyMasked(MatchField.VLAN_VID)) {
-                    Masked<OFVlanVidMatch> masked = match.getMasked(MatchField.VLAN_VID);
-                    if (masked.getValue().equals(OFVlanVidMatch.PRESENT)
-                            && masked.getMask().equals(OFVlanVidMatch.PRESENT)) {
-                        vlanId = VlanId.ANY;
+                if (selectorInterpreter != null &&
+                        selectorInterpreter.supported(ExtensionSelectorTypes.OFDPA_MATCH_VLAN_VID.type())) {
+                    if (match.getVersion().equals(OFVersion.OF_13)) {
+                        OFOxm oxm = ((OFMatchV3) match).getOxmList().get(MatchField.VLAN_VID);
+                        builder.extension(selectorInterpreter.mapOxm(oxm),
+                                DeviceId.deviceId(Dpid.uri(dpid)));
+                    } else {
+                        break;
                     }
                 } else {
-                    if (!match.get(MatchField.VLAN_VID).isPresentBitSet()) {
-                        vlanId = VlanId.NONE;
+                    VlanId vlanId = null;
+                    if (match.isPartiallyMasked(MatchField.VLAN_VID)) {
+                        Masked<OFVlanVidMatch> masked = match.getMasked(MatchField.VLAN_VID);
+                        if (masked.getValue().equals(OFVlanVidMatch.PRESENT)
+                                && masked.getMask().equals(OFVlanVidMatch.PRESENT)) {
+                            vlanId = VlanId.ANY;
+                        }
                     } else {
-                        vlanId = VlanId.vlanId(match.get(MatchField.VLAN_VID).getVlan());
+                        if (!match.get(MatchField.VLAN_VID).isPresentBitSet()) {
+                            vlanId = VlanId.NONE;
+                        } else {
+                            vlanId = VlanId.vlanId(match.get(MatchField.VLAN_VID).getVlan());
+                        }
+                    }
+                    if (vlanId != null) {
+                        builder.matchVlanId(vlanId);
                     }
-                }
-                if (vlanId != null) {
-                    builder.matchVlanId(vlanId);
                 }
                 break;
             case VLAN_PCP:

@@ -240,7 +240,7 @@ public abstract class FlowModBuilder {
                     mBuilder.setExact(MatchField.VLAN_VID, OFVlanVidMatch.NONE);
                 } else {
                     mBuilder.setExact(MatchField.VLAN_VID,
-                                      OFVlanVidMatch.ofVlanVid(VlanVid.ofVlan(vid.vlanId().toShort())));
+                            OFVlanVidMatch.ofVlanVid(VlanVid.ofVlan(vid.vlanId().toShort())));
                 }
                 break;
             case VLAN_PCP:

@@ -20,6 +20,7 @@ import com.google.common.base.Objects;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import org.onosproject.net.driver.DriverService;
 import org.onosproject.net.flow.DefaultTypedFlowEntry;
 import org.onosproject.net.flow.FlowEntry;
 import org.onosproject.net.flow.FlowId;
@@ -55,9 +56,9 @@ import static org.slf4j.LoggerFactory.getLogger;
  * Efficiently and adaptively collects flow statistics for the specified switch.
  */
 public class NewAdaptiveFlowStatsCollector {
-
     private final Logger log = getLogger(getClass());
 
+    private final DriverService driverService;
     private final OpenFlowSwitch sw;
 
     private ScheduledExecutorService adaptiveFlowStatsScheduler =
@@ -109,9 +110,10 @@ public class NewAdaptiveFlowStatsCollector {
      * @param sw           switch to pull
      * @param pollInterval cal and immediate poll frequency in seconds
      */
-    NewAdaptiveFlowStatsCollector(OpenFlowSwitch sw, int pollInterval) {
+    NewAdaptiveFlowStatsCollector(
+            DriverService driverService, OpenFlowSwitch sw, int pollInterval) {
+        this.driverService = driverService;
         this.sw = sw;
-
         initMemberVars(pollInterval);
     }
 
@@ -232,7 +234,7 @@ public class NewAdaptiveFlowStatsCollector {
     private void ofFlowStatsRequestFlowSend(FlowEntry fe) {
         // set find match
         Match match = FlowModBuilder.builder(fe, sw.factory(), Optional.empty(),
-                Optional.empty()).buildMatch();
+                Optional.of(driverService)).buildMatch();
         // set find tableId
         TableId tableId = TableId.of(fe.tableId());
         // set output port

@@ -219,7 +219,8 @@ public class OpenFlowRuleProvider extends AbstractProvider
     private void createCollector(OpenFlowSwitch sw) {
         if (adaptiveFlowSampling) {
             // NewAdaptiveFlowStatsCollector Constructor
-            NewAdaptiveFlowStatsCollector fsc = new NewAdaptiveFlowStatsCollector(sw, flowPollFrequency);
+            NewAdaptiveFlowStatsCollector fsc =
+                    new NewAdaptiveFlowStatsCollector(driverService, sw, flowPollFrequency);
             fsc.start();
             afsCollectors.put(new Dpid(sw.getId()), fsc);
         } else {

@@ -211,10 +211,12 @@ public class OpenFlowMeterProvider extends AbstractProvider implements MeterProv
         }
     }
 
+    // TODO: ONOS-3546 Support per device enabling/disabling via network config
     private boolean isMeterSupported(OpenFlowSwitch sw) {
         if (sw.factory().getVersion() == OFVersion.OF_10 ||
                 sw.factory().getVersion() == OFVersion.OF_11 ||
-                sw.factory().getVersion() == OFVersion.OF_12) {
+                sw.factory().getVersion() == OFVersion.OF_12 ||
+                sw.softwareDescription().equals("OF-DPA 2.0")) {
             return false;
         }