HC2VPP-291: ACL model bump

 - bump ACL yang models
 - fix ACL module implementation and validation
 - fix ACL Unit tests
 - update postman collection

Change-Id: Iaab64e6d92d17babc3ccef7921b41070c3716516
Signed-off-by: Michal Cmarada <mcmarada@cisco.com>

34 files changed, 1806 insertions, 1485 deletions

diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java
new file mode 100644
index 000000000..ad4bcae68
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Set;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRange;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRange;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.icmp.icmp.VppIcmpAce;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.tcp.tcp.VppTcpAce;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Acls;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPoints;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.Aces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.Icmp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.Tcp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.DestinationPort;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.SourcePort;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.Udp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Egress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Ingress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class AclIIds {
+    public final static InstanceIdentifier<Acls> ACLS = InstanceIdentifier.create(Acls.class);
+    public final static InstanceIdentifier<Acl> ACLS_ACL = ACLS.child(Acl.class);
+    public final static InstanceIdentifier<Acl> ACL = InstanceIdentifier.create(Acl.class);
+
+    public final static InstanceIdentifier<AttachmentPoints> ACLS_AP = ACLS.child(AttachmentPoints.class);
+    public final static InstanceIdentifier<Interface> ACLS_AP_INT = ACLS_AP.child(Interface.class);
+    public static final InstanceIdentifier<Ingress> ACLS_AP_INT_ING = ACLS_AP_INT.child(Ingress.class);
+    public static final InstanceIdentifier<AclSets> ACLS_AP_INT_ING_ACLS = ACLS_AP_INT_ING.child(AclSets.class);
+    public static final InstanceIdentifier<AclSet> ACLS_AP_INT_ING_ACLS_ACL = ACLS_AP_INT_ING_ACLS.child(AclSet.class);
+    public static final InstanceIdentifier<Egress> ACLS_AP_INT_EGR = ACLS_AP_INT.child(Egress.class);
+    public static final InstanceIdentifier<AclSets> ACLS_AP_INT_EGR_ACLS = ACLS_AP_INT_EGR.child(AclSets.class);
+    public static final InstanceIdentifier<AclSet> ACLS_AP_INT_EGR_ACLS_ACL = ACLS_AP_INT_EGR_ACLS.child(AclSet.class);
+    public final static InstanceIdentifier<Interface> IFC_ACL = InstanceIdentifier.create(Interface.class);
+    public final static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface>
+            IFC = InstanceIdentifier.create(Interfaces.class)
+            .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface.class);
+    public static final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface>
+            IFC_STATE = InstanceIdentifier.create(InterfacesState.class)
+            .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class);
+
+
+    public static Set<InstanceIdentifier<?>> vppAclChildren(final InstanceIdentifier<Acl> parentId) {
+        final InstanceIdentifier<Matches> matchesIid =
+                parentId.child(Aces.class).child(Ace.class).child(Matches.class);
+        return ImmutableSet.of(
+                parentId.augmentation(VppAclAugmentation.class),
+                parentId.child(Aces.class),
+                parentId.child(Aces.class).child(Ace.class),
+                parentId.child(Aces.class).child(Ace.class).child(Actions.class),
+                matchesIid,
+                matchesIid.child(Eth.class),
+                matchesIid.child(Ipv4.class),
+                matchesIid.child(Ipv6.class),
+                matchesIid.child(Tcp.class),
+                matchesIid.child(Tcp.class).augmentation(VppTcpAceAugmentation.class),
+                matchesIid.child(Tcp.class).augmentation(VppTcpAceAugmentation.class).child(VppTcpAce.class),
+                matchesIid.child(Tcp.class).child(DestinationPort.class),
+                matchesIid.child(Tcp.class).child(SourcePort.class),
+                matchesIid.child(Udp.class),
+                matchesIid.child(Udp.class).child(
+                        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.DestinationPort.class),
+                matchesIid.child(Udp.class).child(
+                        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.SourcePort.class),
+                matchesIid.child(Icmp.class),
+                matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class),
+                matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class),
+                matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class)
+                        .child(IcmpTypeRange.class),
+                matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class)
+                        .child(IcmpCodeRange.class)
+        );
+    }
+
+    public static Set<InstanceIdentifier<?>> aclHandledChildren(final InstanceIdentifier<Interface> parentId) {
+        return ImmutableSet.of(
+                parentId.child(Ingress.class),
+                parentId.child(Ingress.class).child(AclSets.class),
+                parentId.child(Ingress.class).child(AclSets.class).child(AclSet.class),
+                parentId.child(Egress.class),
+                parentId.child(Egress.class).child(AclSets.class),
+                parentId.child(Egress.class).child(AclSets.class).child(AclSet.class));
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java
index afb7da669..a21978e73 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java
@@ -26,8 +26,8 @@ import io.fd.hc2vpp.acl.read.factory.AclReaderFactory;
 import io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory;
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.acl.util.AclContextManagerImpl;
+import io.fd.hc2vpp.acl.write.factory.AclWriterFactory;
 import io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory;
-import io.fd.hc2vpp.acl.write.factory.VppAclWriterFactory;
 import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
@@ -72,7 +72,7 @@ public class AclModule extends AbstractModule {
 
         final Multibinder<WriterFactory> writerFactoryMultibinder =
                 Multibinder.newSetBinder(binder(), WriterFactory.class);
-        writerFactoryMultibinder.addBinding().to(VppAclWriterFactory.class);
+        writerFactoryMultibinder.addBinding().to(AclWriterFactory.class);
         writerFactoryMultibinder.addBinding().to(InterfaceAclWriterFactory.class);
 
         final Multibinder<ReaderFactory> readerFactoryMultibinder =
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java
new file mode 100644
index 000000000..5f6ca36b3
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.read;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableSet;
+import io.fd.hc2vpp.acl.util.AclContextManager;
+import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
+import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.AclDump;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump;
+import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
+import java.util.Arrays;
+import java.util.stream.Stream;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+abstract class AbstractAclCustomizer extends FutureJVppAclCustomizer implements JvppReplyConsumer {
+
+    final NamingContext interfaceContext;
+    final AclContextManager standardAclContext;
+
+    final DumpCacheManager<AclInterfaceListDetailsReplyDump, Integer> aclReferenceDumpManager;
+    final DumpCacheManager<AclDetailsReplyDump, Integer> aclDumpManager;
+
+    protected AbstractAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
+                                    @Nonnull final NamingContext interfaceContext,
+                                    @Nonnull final AclContextManager standardAclContext) {
+        super(jVppAclFacade);
+        this.interfaceContext = interfaceContext;
+        this.standardAclContext = standardAclContext;
+
+        aclReferenceDumpManager =
+                new DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Integer>()
+                        .withExecutor(createAclReferenceDumpExecutor())
+                        // Key needs to contain interface ID to distinguish dumps between interfaces
+                        .withCacheKeyFactory(
+                                new TypeAwareIdentifierCacheKeyFactory(AclInterfaceListDetailsReplyDump.class,
+                                        ImmutableSet.of(Interface.class)))
+                        .build();
+
+        aclDumpManager = new DumpCacheManagerBuilder<AclDetailsReplyDump, Integer>()
+                .withExecutor(createAclExecutor())
+                .acceptOnly(AclDetailsReplyDump.class)
+                .build();
+    }
+
+    private EntityDumpExecutor<AclDetailsReplyDump, Integer> createAclExecutor() {
+        return (identifier, params) -> {
+            AclDump request = new AclDump();
+            request.aclIndex = params;
+            return getReplyForRead(getjVppAclFacade().aclDump(request).toCompletableFuture(), identifier);
+        };
+    }
+
+    private EntityDumpExecutor<AclInterfaceListDetailsReplyDump, Integer> createAclReferenceDumpExecutor() {
+        return (identifier, params) -> {
+            AclInterfaceListDump dumpRequest = new AclInterfaceListDump();
+            dumpRequest.swIfIndex = params;
+            return getReplyForRead(getjVppAclFacade().aclInterfaceListDump(dumpRequest).toCompletableFuture(),
+                    identifier);
+        };
+    }
+
+    Stream<AclSetKey> getStandardAclSetKeys(@Nonnull final ReadContext readContext,
+                                            final Optional<AclInterfaceListDetailsReplyDump> dumpReply,
+                                            final boolean isIngress) {
+        if (dumpReply.isPresent() && !dumpReply.get().aclInterfaceListDetails.isEmpty()) {
+            // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be
+            // dump message in vpp)
+            final AclInterfaceListDetails aclDetails = dumpReply.get().aclInterfaceListDetails.get(0);
+
+            if (isIngress) {
+                return Arrays.stream(aclDetails.acls).limit(aclDetails.nInput)
+                        .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, readContext.getMappingContext()))
+                        .map(AclSetKey::new);
+            } else {
+                return Arrays.stream(aclDetails.acls).skip(aclDetails.nInput)
+                        .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, readContext.getMappingContext()))
+                        .map(AclSetKey::new);
+            }
+        } else {
+            return Stream.empty();
+        }
+    }
+
+    void parseStandardAclSet(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                             @Nonnull final AclSetBuilder aclSetBuilder, final String aclName,
+                             final MappingContext mappingContext, final ModificationCache modificationCache)
+            throws ReadFailedException {
+        final int aclIndex = standardAclContext.getAclIndex(aclName, mappingContext);
+
+        final Optional<AclDetailsReplyDump> dumpReply =
+                aclDumpManager.getDump(instanceIdentifier, modificationCache, aclIndex);
+
+        if (dumpReply.isPresent() && !dumpReply.get().aclDetails.isEmpty()) {
+            aclSetBuilder.setName(aclName);
+        } else {
+            throw new ReadFailedException(instanceIdentifier,
+                    new IllegalArgumentException(String.format("Acl with name %s not found", aclName)));
+        }
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java
deleted file mode 100644
index c6d61f653..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.read;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
-import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
-import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump;
-import io.fd.vpp.jvpp.acl.dto.AclDump;
-import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails;
-import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump;
-import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump;
-import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-abstract class AbstractVppAclCustomizer extends FutureJVppAclCustomizer
-    implements InitializingListReaderCustomizer<VppAcls, VppAclsKey, VppAclsBuilder>, JvppReplyConsumer,
-    ByteDataTranslator {
-
-    private final NamingContext interfaceContext;
-    private final AclContextManager standardAclContext;
-
-    private final DumpCacheManager<AclInterfaceListDetailsReplyDump, Integer> aclReferenceDumpManager;
-    private final DumpCacheManager<AclDetailsReplyDump, Integer> aclDumpManager;
-
-    protected AbstractVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                                       @Nonnull final NamingContext interfaceContext,
-                                       @Nonnull final AclContextManager standardAclContext) {
-        super(jVppAclFacade);
-        this.interfaceContext = interfaceContext;
-        this.standardAclContext = standardAclContext;
-
-        aclReferenceDumpManager =
-            new DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Integer>()
-                .withExecutor(createAclReferenceDumpExecutor())
-                // Key needs to contain interface ID to distinguish dumps between interfaces
-                .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(AclInterfaceListDetailsReplyDump.class,
-                    ImmutableSet.of(Interface.class)))
-                .build();
-
-        aclDumpManager = new DumpCacheManagerBuilder<AclDetailsReplyDump, Integer>()
-            .withExecutor(createAclExecutor())
-            .acceptOnly(AclDetailsReplyDump.class)
-            .build();
-    }
-
-    protected static InstanceIdentifier<Acl> getAclCfgId(
-        final InstanceIdentifier<Acl> id) {
-        return InstanceIdentifier.create(Interfaces.class).child(
-            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface.class,
-            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey(
-                id.firstKeyOf(Interface.class).getName())).augmentation(VppAclInterfaceAugmentation.class)
-            .child(Acl.class);
-    }
-
-    private EntityDumpExecutor<AclDetailsReplyDump, Integer> createAclExecutor() {
-        return (identifier, params) -> {
-            AclDump request = new AclDump();
-            request.aclIndex = params;
-            return getReplyForRead(getjVppAclFacade().aclDump(request).toCompletableFuture(), identifier);
-        };
-    }
-
-    private EntityDumpExecutor<AclInterfaceListDetailsReplyDump, Integer> createAclReferenceDumpExecutor() {
-        return (identifier, params) -> {
-            AclInterfaceListDump dumpRequest = new AclInterfaceListDump();
-            dumpRequest.swIfIndex = params;
-            return getReplyForRead(getjVppAclFacade().aclInterfaceListDump(dumpRequest).toCompletableFuture(),
-                identifier);
-        };
-    }
-
-    @Nonnull
-    @Override
-    public final List<VppAclsKey> getAllIds(@Nonnull final InstanceIdentifier<VppAcls> id,
-                                            @Nonnull final ReadContext context)
-        throws ReadFailedException {
-
-        final String parentInterfaceName = id.firstKeyOf(Interface.class).getName();
-        final int parentInterfaceIndex = interfaceContext.getIndex(parentInterfaceName, context.getMappingContext());
-
-        final Optional<AclInterfaceListDetailsReplyDump> dumpReply =
-            aclReferenceDumpManager.getDump(id, context.getModificationCache(), parentInterfaceIndex);
-
-        if (dumpReply.isPresent() && !dumpReply.get().aclInterfaceListDetails.isEmpty()) {
-            // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be
-            // dump message in vpp)
-            final AclInterfaceListDetails aclDetails = dumpReply.get().aclInterfaceListDetails.get(0);
-            return filterAcls(aclDetails)
-                .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, context.getMappingContext()))
-                .map(aclName -> new VppAclsKey(aclName, VppAcl.class))
-                .collect(Collectors.toList());
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    /**
-     * Streams ids of ACLs.
-     *
-     * @param aclDetails describes ACLs assigned to interface
-     * @return sequence of acl ids
-     */
-    protected abstract IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails);
-
-    @Nonnull
-    @Override
-    public final VppAclsBuilder getBuilder(@Nonnull final InstanceIdentifier<VppAcls> id) {
-        return new VppAclsBuilder();
-    }
-
-    @Override
-    public final void readCurrentAttributes(@Nonnull final InstanceIdentifier<VppAcls> id,
-                                            @Nonnull final VppAclsBuilder builder,
-                                            @Nonnull final ReadContext ctx) throws ReadFailedException {
-        final VppAclsKey vppAclsKey = id.firstKeyOf(VppAcls.class);
-        final String aclName = vppAclsKey.getName();
-        final int aclIndex = standardAclContext.getAclIndex(aclName, ctx.getMappingContext());
-
-        final Optional<AclDetailsReplyDump> dumpReply =
-            aclDumpManager.getDump(id, ctx.getModificationCache(), aclIndex);
-
-        if (dumpReply.isPresent() && !dumpReply.get().aclDetails.isEmpty()) {
-            builder.setName(aclName);
-            builder.setType(vppAclsKey.getType());
-        } else {
-            throw new ReadFailedException(id,
-                new IllegalArgumentException(String.format("Acl with name %s not found", aclName)));
-        }
-    }
-
-    @Nonnull
-    @Override
-    public Initialized<VppAcls> init(@Nonnull final InstanceIdentifier<VppAcls> id,
-                                     @Nonnull final VppAcls vppAcls,
-                                     @Nonnull final ReadContext readContext) {
-        return Initialized.create(getCfgId(id), vppAcls);
-    }
-
-    protected abstract InstanceIdentifier<VppAcls> getCfgId(final InstanceIdentifier<VppAcls> id);
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java
index 0ebc938ea..e1f0ccf14 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java
@@ -41,16 +41,13 @@ import java.util.ArrayList;
 import java.util.List;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessListsBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclKey;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntriesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.AcesBuilder;
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@@ -119,7 +116,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer
         if (vppAclDump.isPresent()) {
             vppAclDump.get().aclDetails.stream()
                 .map(details -> standardAclContext.getAclName(details.aclIndex, context.getMappingContext()))
-                .forEach(name -> keys.add(new AclKey(name, VppAcl.class)));
+                    .forEach(name -> keys.add(new AclKey(name)));
         }
 
         final Optional<MacipAclDetailsReplyDump> macipAclDump =
@@ -127,7 +124,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer
         if (macipAclDump.isPresent()) {
             macipAclDump.get().macipAclDetails.stream()
                 .map(details -> macipAclContext.getAclName(details.aclIndex, context.getMappingContext()))
-                .forEach(name -> keys.add(new AclKey(name, VppMacipAcl.class)));
+                    .forEach(name -> keys.add(new AclKey(name)));
         }
 
         return keys;
@@ -135,7 +132,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer
 
     @Override
     public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Acl> readData) {
-        ((AccessListsBuilder)builder).setAcl(readData);
+        ((AclsBuilder) builder).setAcl(readData);
     }
 
     @Nonnull
@@ -149,10 +146,9 @@ public class AclCustomizer extends FutureJVppAclCustomizer
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
         final AclKey key = id.firstKeyOf(Acl.class);
         builder.withKey(key);
-        final Class<? extends AclBase> aclType = key.getAclType();
-        final String name = key.getAclName();
+        final String name = key.getName();
 
-        if (aclType.equals(VppAcl.class)) {
+        if (standardAclContext.containsAcl(name, ctx.getMappingContext())) {
             final int index = standardAclContext.getAclIndex(name, ctx.getMappingContext());
             final Optional<AclDetailsReplyDump> dump = vppAclDumpManager.getDump(id, ctx.getModificationCache(), index);
 
@@ -162,12 +158,12 @@ public class AclCustomizer extends FutureJVppAclCustomizer
                 if (detail.isPresent()) {
                     final AclDetails aclDetails = detail.get();
                     setTag(builder, aclDetails.tag);
-                    builder.setAccessListEntries(new AccessListEntriesBuilder()
+                    builder.setAces(new AcesBuilder()
                         .setAce(toStandardAces(name, aclDetails.r, standardAclContext, ctx.getMappingContext()))
                         .build());
                 }
             }
-        } else if (aclType.equals(VppMacipAcl.class)) {
+        } else if (macipAclContext.containsAcl(name, ctx.getMappingContext())) {
             final int index = macipAclContext.getAclIndex(name, ctx.getMappingContext());
             final Optional<MacipAclDetailsReplyDump> dump =
                 macipAclDumpManager.getDump(id, ctx.getModificationCache(), index);
@@ -178,13 +174,13 @@ public class AclCustomizer extends FutureJVppAclCustomizer
                 final MacipAclDetails macipAclDetails = detail.get();
                 setTag(builder, macipAclDetails.tag);
                 if (detail.isPresent()) {
-                    builder.setAccessListEntries(new AccessListEntriesBuilder()
+                    builder.setAces(new AcesBuilder()
                         .setAce(toMacIpAces(name, macipAclDetails.r, macipAclContext, ctx.getMappingContext()))
                         .build());
                 }
             }
         } else {
-            throw new IllegalArgumentException("Unsupported acl type: " + aclType);
+            throw new IllegalArgumentException("Unsupported acl: " + id);
         }
     }
 
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java
new file mode 100644
index 000000000..59990d5ea
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.read;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.acl.util.AclContextManager;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class EgressAclCustomizer extends AbstractAclCustomizer
+        implements InitializingListReaderCustomizer<AclSet, AclSetKey, AclSetBuilder>, JvppReplyConsumer {
+
+    public EgressAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext,
+                               final AclContextManager standardAclContext) {
+        super(futureAclFacade, interfaceContext, standardAclContext);
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                                  @Nonnull final AclSet aclSet,
+                                                  @Nonnull final ReadContext readContext) {
+        return Initialized.create(instanceIdentifier, aclSet);
+    }
+
+    @Nonnull
+    @Override
+    public List<AclSetKey> getAllIds(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                     @Nonnull final ReadContext readContext) throws ReadFailedException {
+        final String parentInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId();
+        final int parentInterfaceIndex =
+                interfaceContext.getIndex(parentInterfaceName, readContext.getMappingContext());
+
+        //TODO stdDumpReply keys need to be filtered as egress only
+        final Optional<AclInterfaceListDetailsReplyDump> stdDumpReply =
+                aclReferenceDumpManager
+                        .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex);
+
+        return getStandardAclSetKeys(readContext, stdDumpReply, false).collect(Collectors.toList());
+    }
+
+    @Override
+    public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<AclSet> list) {
+        ((AclSetsBuilder) builder).setAclSet(list);
+    }
+
+    @Nonnull
+    @Override
+    public AclSetBuilder getBuilder(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier) {
+        return new AclSetBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                      @Nonnull final AclSetBuilder aclSetBuilder,
+                                      @Nonnull final ReadContext readContext)
+            throws ReadFailedException {
+        final AclSetKey vppAclsKey = instanceIdentifier.firstKeyOf(AclSet.class);
+        final String aclName = vppAclsKey.getName();
+        final MappingContext mappingContext = readContext.getMappingContext();
+        ModificationCache modificationCache = readContext.getModificationCache();
+
+        if (standardAclContext.containsAcl(aclName, mappingContext)) {
+            parseStandardAclSet(instanceIdentifier, aclSetBuilder, aclName, mappingContext, modificationCache);
+        }
+
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java
deleted file mode 100644
index 8e5d0dfce..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.read;
-
-import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails;
-import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.EgressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public final class EgressVppAclCustomizer extends AbstractVppAclCustomizer {
-
-    public EgressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                                  @Nonnull final NamingContext interfaceContext,
-                                  @Nonnull final AclContextManager standardAclContext) {
-        super(jVppAclFacade, interfaceContext, standardAclContext);
-    }
-
-    @Override
-    protected IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails) {
-        return Arrays.stream(aclDetails.acls).skip(aclDetails.nInput);
-    }
-
-    @Override
-    public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VppAcls> readData) {
-        EgressBuilder.class.cast(builder).setVppAcls(readData);
-    }
-
-    @Override
-    protected InstanceIdentifier<VppAcls> getCfgId(
-        final InstanceIdentifier<VppAcls> id) {
-        return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Egress.class)
-            .child(VppAcls.class, id.firstKeyOf(VppAcls.class));
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java
new file mode 100644
index 000000000..467c4e5db
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.read;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Streams;
+import io.fd.hc2vpp.acl.util.AclContextManager;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGet;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGetReply;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetails;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDump;
+import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class IngressAclCustomizer extends AbstractAclCustomizer
+        implements InitializingListReaderCustomizer<AclSet, AclSetKey, AclSetBuilder>, JvppReplyConsumer {
+    @VisibleForTesting
+    protected static final int ACL_NOT_ASSIGNED = -1;
+    private static final Logger LOG = LoggerFactory.getLogger(IngressAclCustomizer.class);
+
+    private final AclContextManager macIpAclContext;
+
+    private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macIpAclDumpManager;
+    private final DumpCacheManager<MacipAclInterfaceGetReply, Void> interfaceMacIpAclDumpManager;
+    private final DumpCacheManager<MacipAclInterfaceListDetailsReplyDump, Integer> macAclReferenceDumpManager;
+
+    public IngressAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext,
+                                final AclContextManager standardAclContext, final AclContextManager macIpAClContext) {
+        super(futureAclFacade, interfaceContext, standardAclContext);
+        this.macIpAclContext = macIpAClContext;
+
+        macAclReferenceDumpManager =
+                new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceListDetailsReplyDump, Integer>()
+                        .withExecutor(createMacIpAclReferenceDumpExecutor())
+                        // Key needs to contain interface ID to distinguish dumps between interfaces
+                        .withCacheKeyFactory(
+                                new TypeAwareIdentifierCacheKeyFactory(MacipAclInterfaceListDetailsReplyDump.class,
+                                        ImmutableSet.of(Interface.class)))
+                        .build();
+
+        // for dumping of Mac-ip details
+        macIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclDetailsReplyDump, Integer>()
+                .withExecutor(createMacIpDumpExecutor())
+                .acceptOnly(MacipAclDetailsReplyDump.class)
+                .build();
+
+        // for dumping of reference on interface
+        interfaceMacIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceGetReply, Void>()
+                .withExecutor(createInterfaceMacIpDumpExecutor())
+                .acceptOnly(MacipAclInterfaceGetReply.class)
+                .build();
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                                  @Nonnull final AclSet aclSet,
+                                                  @Nonnull final ReadContext readContext) {
+        return Initialized.create(instanceIdentifier, aclSet);
+    }
+
+    @Nonnull
+    @Override
+    public List<AclSetKey> getAllIds(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                     @Nonnull final ReadContext readContext) throws ReadFailedException {
+        final String parentInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId();
+        final int parentInterfaceIndex =
+                interfaceContext.getIndex(parentInterfaceName, readContext.getMappingContext());
+
+        //TODO stdDumpReply keys need to be filtered as ingress only
+        final Optional<AclInterfaceListDetailsReplyDump> stdDumpReply =
+                aclReferenceDumpManager
+                        .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex);
+        final Optional<MacipAclInterfaceListDetailsReplyDump> macipDumpReply =
+                macAclReferenceDumpManager
+                        .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex);
+
+        Stream<AclSetKey> macIpAclSetKeys = getMacIpAclSetKeys(readContext, macipDumpReply);
+        Stream<AclSetKey> standardAclSetKeys = getStandardAclSetKeys(readContext, stdDumpReply, true);
+
+        return Streams.concat(standardAclSetKeys, macIpAclSetKeys).distinct().collect(Collectors.toList());
+    }
+
+    @Override
+    public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<AclSet> list) {
+        ((AclSetsBuilder) builder).setAclSet(list);
+    }
+
+    @Nonnull
+    @Override
+    public AclSetBuilder getBuilder(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier) {
+        return new AclSetBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                      @Nonnull final AclSetBuilder aclSetBuilder,
+                                      @Nonnull final ReadContext readContext) throws ReadFailedException {
+        final AclSetKey vppAclsKey = instanceIdentifier.firstKeyOf(AclSet.class);
+        final String interfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId();
+        final String aclName = vppAclsKey.getName();
+        final MappingContext mappingContext = readContext.getMappingContext();
+        ModificationCache modificationCache = readContext.getModificationCache();
+
+        if (standardAclContext.containsAcl(aclName, mappingContext)) {
+            parseStandardAclSet(instanceIdentifier, aclSetBuilder, aclName, mappingContext, modificationCache);
+        } else if (macIpAclContext.containsAcl(aclName, mappingContext)) {
+            parseMacIpAclSet(instanceIdentifier, aclSetBuilder, interfaceName, mappingContext, modificationCache);
+        }
+    }
+
+    public void parseMacIpAclSet(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier,
+                                 @Nonnull final AclSetBuilder aclSetBuilder,
+                                 final String interfaceName, final MappingContext mappingContext,
+                                 final ModificationCache modificationCache)
+            throws ReadFailedException {
+        final Optional<MacipAclInterfaceGetReply> interfacesMacIpDumpReply =
+                interfaceMacIpAclDumpManager.getDump(instanceIdentifier, modificationCache);
+        final int interfaceIndex = interfaceContext.getIndex(interfaceName, mappingContext);
+        MacipAclInterfaceGetReply reply = interfacesMacIpDumpReply.get();
+        if (reply.acls == null || reply.acls.length == 0) {
+            LOG.debug("No MacACls found for interface. Iid: {}", instanceIdentifier);
+            return;
+        }
+        final int aclIndex = reply.acls[interfaceIndex];
+        if (aclIndex != ACL_NOT_ASSIGNED) {
+            final Optional<MacipAclDetailsReplyDump> macIpDumpReply =
+                    macIpAclDumpManager.getDump(instanceIdentifier, modificationCache, aclIndex);
+
+            if (macIpDumpReply.isPresent() && !macIpDumpReply.get().macipAclDetails.isEmpty()) {
+                aclSetBuilder.setName(macIpAclContext.getAclName(aclIndex, mappingContext));
+            } else {
+                // this is invalid state(Interface in VPP will act as "deny-all" for security reasons), but generally
+                // it should not happen
+                throw new ReadFailedException(instanceIdentifier,
+                        new IllegalStateException(String.format("ACE with index %s not found in VPP", aclIndex)));
+            }
+        }
+    }
+
+    private EntityDumpExecutor<MacipAclInterfaceListDetailsReplyDump, Integer> createMacIpAclReferenceDumpExecutor() {
+        return (identifier, params) -> {
+            MacipAclInterfaceListDump dumpRequest = new MacipAclInterfaceListDump();
+            dumpRequest.swIfIndex = params;
+            return getReplyForRead(getjVppAclFacade().macipAclInterfaceListDump(dumpRequest).toCompletableFuture(),
+                    identifier);
+        };
+    }
+
+    private EntityDumpExecutor<MacipAclDetailsReplyDump, Integer> createMacIpDumpExecutor() {
+        return (identifier, params) -> {
+            MacipAclDump request = new MacipAclDump();
+            request.aclIndex = params;
+
+            return getReplyForRead(getjVppAclFacade().macipAclDump(request).toCompletableFuture(), identifier);
+        };
+    }
+
+    private EntityDumpExecutor<MacipAclInterfaceGetReply, Void> createInterfaceMacIpDumpExecutor() {
+        return (identifier, params) -> getReplyForRead(
+                getjVppAclFacade().macipAclInterfaceGet(new MacipAclInterfaceGet()).toCompletableFuture(),
+                identifier);
+    }
+
+
+    private Stream<AclSetKey> getMacIpAclSetKeys(@Nonnull final ReadContext readContext,
+                                                 final Optional<MacipAclInterfaceListDetailsReplyDump> dumpReply) {
+        if (dumpReply.isPresent() && !dumpReply.get().macipAclInterfaceListDetails.isEmpty()) {
+            // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be
+            // dump message in vpp)
+            final MacipAclInterfaceListDetails aclDetails = dumpReply.get().macipAclInterfaceListDetails.get(0);
+
+            return Arrays.stream(aclDetails.acls).limit(aclDetails.count)
+                    .mapToObj(aclIndex -> macIpAclContext.getAclName(aclIndex, readContext.getMappingContext()))
+                    .map(AclSetKey::new);
+        } else {
+            return Stream.empty();
+        }
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java
deleted file mode 100644
index 598066282..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.read;
-
-import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails;
-import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public final class IngressVppAclCustomizer extends AbstractVppAclCustomizer {
-
-    public IngressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                                   @Nonnull final NamingContext interfaceContext,
-                                   @Nonnull final AclContextManager standardAclContext) {
-        super(jVppAclFacade, interfaceContext, standardAclContext);
-    }
-
-    @Override
-    protected IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails) {
-        return Arrays.stream(aclDetails.acls).limit(aclDetails.nInput);
-    }
-
-    @Override
-    public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VppAcls> readData) {
-        IngressBuilder.class.cast(builder).setVppAcls(readData);
-    }
-
-    @Override
-    protected InstanceIdentifier<VppAcls> getCfgId(
-        final InstanceIdentifier<VppAcls> id) {
-        return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Ingress.class)
-            .child(VppAcls.class, id.firstKeyOf(VppAcls.class));
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java
new file mode 100644
index 000000000..64720de5d
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.read;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Streams;
+import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump;
+import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDump;
+import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements
+        InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, JvppReplyConsumer {
+    private final NamingContext interfaceContext;
+
+    private final DumpCacheManager<MacipAclInterfaceListDetailsReplyDump, Void> macipAclInterfaceListDumpManager;
+    private final DumpCacheManager<AclInterfaceListDetailsReplyDump, Void> aclInterfaceListDumpManager;
+
+    public InterfaceAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext) {
+        super(futureAclFacade);
+        this.interfaceContext = interfaceContext;
+
+        //list all standard ACL interfaces
+        AclInterfaceListDump aclInterfaceListDump = new AclInterfaceListDump();
+        aclInterfaceListDump.swIfIndex = -1;
+        aclInterfaceListDumpManager =
+                new DumpCacheManager.DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Void>()
+                        .withExecutor((identifier, params) -> getReplyForRead(
+                                getjVppAclFacade().aclInterfaceListDump(aclInterfaceListDump).toCompletableFuture(),
+                                identifier))
+                        .acceptOnly(AclInterfaceListDetailsReplyDump.class)
+                        .build();
+
+        //list all macIp ACL interfaces
+        MacipAclInterfaceListDump macipAclInterfaceListDump = new MacipAclInterfaceListDump();
+        macipAclInterfaceListDump.swIfIndex = 0;
+        macipAclInterfaceListDumpManager =
+                new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceListDetailsReplyDump, Void>()
+                        .withExecutor((identifier, params) -> getReplyForRead(
+                                getjVppAclFacade().macipAclInterfaceListDump(macipAclInterfaceListDump)
+                                        .toCompletableFuture(),
+                                identifier))
+                        .acceptOnly(MacipAclInterfaceListDetailsReplyDump.class)
+                        .build();
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
+                                                  @Nonnull final Interface anInterface,
+                                                  @Nonnull final ReadContext readContext) {
+        return Initialized.create(instanceIdentifier, anInterface);
+    }
+
+    @Nonnull
+    @Override
+    public List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
+                                        @Nonnull final ReadContext readContext) throws ReadFailedException {
+        final Optional<AclInterfaceListDetailsReplyDump> stdIfcDumpReply =
+                aclInterfaceListDumpManager.getDump(instanceIdentifier, readContext.getModificationCache());
+
+        final Optional<MacipAclInterfaceListDetailsReplyDump> macIpIfcDumpReply =
+                macipAclInterfaceListDumpManager.getDump(instanceIdentifier, readContext.getModificationCache());
+
+        Stream<InterfaceKey> stdAclIfcKeys = stdIfcDumpReply.asSet().stream()
+                .map(dump -> dump.aclInterfaceListDetails)
+                .flatMap(Collection::stream)
+                .filter(aclInterfaceListDetails -> aclInterfaceListDetails.acls.length != 0)
+                .map(details -> getInterfaceKey(readContext, details.swIfIndex));
+
+        Stream<InterfaceKey> macIpAclIfcKeys = macIpIfcDumpReply.asSet().stream()
+                .map(dump -> dump.macipAclInterfaceListDetails)
+                .flatMap(Collection::stream)
+                .map(details -> getInterfaceKey(readContext, details.swIfIndex));
+        return Streams.concat(stdAclIfcKeys, macIpAclIfcKeys).distinct().collect(Collectors.toList());
+    }
+
+    private InterfaceKey getInterfaceKey(@Nonnull final ReadContext readContext, final int swIfIndex) {
+        return new InterfaceKey(interfaceContext.getName(swIfIndex, readContext.getMappingContext()));
+    }
+
+    @Override
+    public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Interface> list) {
+        ((AttachmentPointsBuilder) builder).setInterface(list);
+    }
+
+    @Nonnull
+    @Override
+    public InterfaceBuilder getBuilder(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier) {
+        return new InterfaceBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
+                                      @Nonnull final InterfaceBuilder interfaceBuilder,
+                                      @Nonnull final ReadContext readContext)
+            throws ReadFailedException {
+        interfaceBuilder.withKey(instanceIdentifier.firstKeyOf(Interface.class));
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java
deleted file mode 100644
index 0ae05826c..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.read;
-
-import static io.fd.hc2vpp.acl.read.AbstractVppAclCustomizer.getAclCfgId;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
-import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.MappingContext;
-import io.fd.honeycomb.translate.ModificationCache;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.vpp.jvpp.acl.dto.MacipAclDetailsReplyDump;
-import io.fd.vpp.jvpp.acl.dto.MacipAclDump;
-import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGet;
-import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGetReply;
-import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAclBuilder;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class VppMacIpAclCustomizer extends FutureJVppAclCustomizer
-    implements InitializingReaderCustomizer<VppMacipAcl, VppMacipAclBuilder>, JvppReplyConsumer, ByteDataTranslator {
-
-    private static final Logger LOG = LoggerFactory.getLogger(VppMacIpAclCustomizer.class);
-    @VisibleForTesting
-    protected static final int ACL_NOT_ASSIGNED = -1;
-
-    private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macIpAclDumpManager;
-    private final DumpCacheManager<MacipAclInterfaceGetReply, Void> interfaceMacIpAclDumpManager;
-    private final NamingContext interfaceContext;
-    private final AclContextManager macIpAclContext;
-
-    public VppMacIpAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                                 @Nonnull final NamingContext interfaceContext,
-                                 @Nonnull final AclContextManager macIpAclContext) {
-        super(jVppAclFacade);
-
-        // for dumping of Mac-ip details
-        macIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclDetailsReplyDump, Integer>()
-            .withExecutor(createMacIpDumpExecutor())
-            .acceptOnly(MacipAclDetailsReplyDump.class)
-            .build();
-
-        // for dumping of reference on interface
-        interfaceMacIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceGetReply, Void>()
-            .withExecutor(createInterfaceMacIpDumpExecutor())
-            .acceptOnly(MacipAclInterfaceGetReply.class)
-            .build();
-        this.interfaceContext = interfaceContext;
-        this.macIpAclContext = macIpAclContext;
-    }
-
-    private static InstanceIdentifier<VppMacipAcl> getCfgId(
-        final InstanceIdentifier<VppMacipAcl> id) {
-        return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Ingress.class).child(VppMacipAcl.class);
-    }
-
-    private EntityDumpExecutor<MacipAclDetailsReplyDump, Integer> createMacIpDumpExecutor() {
-        return (identifier, params) -> {
-            MacipAclDump request = new MacipAclDump();
-            request.aclIndex = params;
-
-            return getReplyForRead(getjVppAclFacade().macipAclDump(request).toCompletableFuture(), identifier);
-        };
-    }
-
-    private EntityDumpExecutor<MacipAclInterfaceGetReply, Void> createInterfaceMacIpDumpExecutor() {
-        return (identifier, params) -> getReplyForRead(
-            getjVppAclFacade().macipAclInterfaceGet(new MacipAclInterfaceGet()).toCompletableFuture(),
-            identifier);
-    }
-
-    @Nonnull
-    @Override
-    public VppMacipAclBuilder getBuilder(@Nonnull final InstanceIdentifier<VppMacipAcl> id) {
-        return new VppMacipAclBuilder();
-    }
-
-    @Override
-    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
-                                      @Nonnull final VppMacipAclBuilder builder,
-                                      @Nonnull final ReadContext ctx) throws ReadFailedException {
-        final String interfaceName = id.firstKeyOf(Interface.class).getName();
-        final MappingContext mappingContext = ctx.getMappingContext();
-        final int interfaceIndex = interfaceContext.getIndex(interfaceName, mappingContext);
-        final ModificationCache modificationCache = ctx.getModificationCache();
-        final Optional<MacipAclInterfaceGetReply> interfacesMacIpDumpReply =
-            interfaceMacIpAclDumpManager.getDump(id, modificationCache);
-
-        if (interfacesMacIpDumpReply.isPresent() && interfaceIndex < interfacesMacIpDumpReply.get().count) {
-            final int aclIndex = interfacesMacIpDumpReply.get().acls[interfaceIndex];
-            if (aclIndex != ACL_NOT_ASSIGNED) {
-                final Optional<MacipAclDetailsReplyDump> macIpDumpReply =
-                    macIpAclDumpManager.getDump(id, modificationCache, aclIndex);
-
-                if (macIpDumpReply.isPresent() && !macIpDumpReply.get().macipAclDetails.isEmpty()) {
-                    builder.setName(macIpAclContext.getAclName(aclIndex, mappingContext));
-                    builder.setType(
-                        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl.class);
-                    return;
-                } else {
-                    // this is invalid state(Interface in VPP will act as "deny-all" for security reasons), but generally
-                    // it should not happen
-                    throw new ReadFailedException(id,
-                        new IllegalStateException(String.format("ACE with index %s not found in VPP", aclIndex)));
-                }
-            }
-        }
-        // this is valid state, so just logging
-        LOG.debug("No Mac-ip ACL specified for Interface name={},index={}", interfaceName, interfaceIndex);
-    }
-
-    @Override
-    public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
-                      @Nonnull final VppMacipAcl readValue) {
-        IngressBuilder.class.cast(parentBuilder).setVppMacipAcl(readValue);
-    }
-
-    @Nonnull
-    @Override
-    public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
-                                                  @Nonnull final VppMacipAcl readValue,
-                                                  @Nonnull final ReadContext ctx) {
-        return Initialized.create(getCfgId(id), readValue);
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java
index 34352e8f3..6a743ca80 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java
@@ -16,27 +16,23 @@
 
 package io.fd.hc2vpp.acl.read.factory;
 
-import static io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory.ACL_EGRESS_IID;
-import static io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory.ACL_INGRESS_IID;
+import static io.fd.hc2vpp.acl.AclIIds.vppAclChildren;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.Inject;
 import com.google.inject.name.Named;
+import io.fd.hc2vpp.acl.AclIIds;
 import io.fd.hc2vpp.acl.AclModule;
 import io.fd.hc2vpp.acl.read.AclCustomizer;
 import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.acl.util.factory.AclFactory;
 import io.fd.honeycomb.translate.impl.read.GenericInitListReader;
 import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessLists;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessListsBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclsBuilder;
 
-public class AclReaderFactory implements ReaderFactory, AclFactory {
+public class AclReaderFactory implements ReaderFactory {
 
     @Inject
     private FutureJVppAclFacade futureAclFacade;
@@ -49,16 +45,13 @@ public class AclReaderFactory implements ReaderFactory, AclFactory {
     @Named(AclModule.MAC_IP_ACL_CONTEXT_NAME)
     private AclContextManager macIpAClContext;
 
-    private static final InstanceIdentifier<AccessLists> ACLS_ID = InstanceIdentifier.create(AccessLists.class);
-    private static final InstanceIdentifier<Acl> ACL_ID = ACLS_ID.child(Acl.class);
-
     @Override
     public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
-        registry.addStructuralReader(ACLS_ID, AccessListsBuilder.class);
+        registry.addStructuralReader(AclIIds.ACLS, AclsBuilder.class);
 
-        registry.subtreeAddBefore(vppAclChildren(InstanceIdentifier.create(Acl.class)),
-            new GenericInitListReader<>(ACL_ID,
+        registry.subtreeAddBefore(vppAclChildren(AclIIds.ACL),
+                new GenericInitListReader<>(AclIIds.ACLS_ACL,
                 new AclCustomizer(futureAclFacade, standardAclContext, macIpAClContext)),
-            ImmutableSet.of(ACL_INGRESS_IID, ACL_EGRESS_IID));
+                ImmutableSet.of(AclIIds.ACLS_AP_INT_ING, AclIIds.ACLS_AP_INT_EGR));
     }
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java
index 173223648..1c4f0d982 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java
@@ -18,31 +18,22 @@ package io.fd.hc2vpp.acl.read.factory;
 
 import com.google.inject.Inject;
 import com.google.inject.name.Named;
+import io.fd.hc2vpp.acl.AclIIds;
 import io.fd.hc2vpp.acl.AclModule;
-import io.fd.hc2vpp.acl.read.EgressVppAclCustomizer;
-import io.fd.hc2vpp.acl.read.IngressVppAclCustomizer;
-import io.fd.hc2vpp.acl.read.VppMacIpAclCustomizer;
+import io.fd.hc2vpp.acl.read.InterfaceAclCustomizer;
+import io.fd.hc2vpp.acl.read.EgressAclCustomizer;
+import io.fd.hc2vpp.acl.read.IngressAclCustomizer;
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.honeycomb.translate.impl.read.GenericInitListReader;
-import io.fd.honeycomb.translate.impl.read.GenericInitReader;
 import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceStateAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceStateAugmentationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.AclBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.EgressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.EgressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.IngressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder;
 
 public class InterfaceAclReaderFactory implements ReaderFactory {
 
@@ -61,27 +52,23 @@ public class InterfaceAclReaderFactory implements ReaderFactory {
     @Named("interface-context")
     private NamingContext interfaceContext;
 
-    private static final InstanceIdentifier<Interface>
-        IFC_ID = InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
-    private static final InstanceIdentifier<VppAclInterfaceStateAugmentation> VPP_ACL_AUG_IID =
-        IFC_ID.augmentation(VppAclInterfaceStateAugmentation.class);
-    static final InstanceIdentifier<Acl> ACL_IID = VPP_ACL_AUG_IID.child(Acl.class);
-    static final InstanceIdentifier<Ingress> ACL_INGRESS_IID = ACL_IID.child(Ingress.class);
-    static final InstanceIdentifier<Egress> ACL_EGRESS_IID = ACL_IID.child(Egress.class);
-
     @Override
     public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
-        registry.addStructuralReader(VPP_ACL_AUG_IID, VppAclInterfaceStateAugmentationBuilder.class);
-        registry.addStructuralReader(ACL_IID, AclBuilder.class);
+        registry.addStructuralReader(AclIIds.ACLS_AP, AttachmentPointsBuilder.class);
+
+        registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT,
+                        new InterfaceAclCustomizer(futureAclFacade, interfaceContext)),
+                AclIIds.IFC_STATE);
 
-        registry.addStructuralReader(ACL_INGRESS_IID, IngressBuilder.class);
-        registry.addAfter(new GenericInitListReader<>(ACL_INGRESS_IID.child(VppAcls.class),
-            new IngressVppAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID);
-        registry.addAfter(new GenericInitReader<>(ACL_INGRESS_IID.child(VppMacipAcl.class),
-            new VppMacIpAclCustomizer(futureAclFacade, interfaceContext, macIpAClContext)), IFC_ID);
+        registry.addStructuralReader(AclIIds.ACLS_AP_INT_ING, IngressBuilder.class);
+        registry.addStructuralReader(AclIIds.ACLS_AP_INT_EGR, EgressBuilder.class);
+        registry.addStructuralReader(AclIIds.ACLS_AP_INT_ING_ACLS, AclSetsBuilder.class);
+        registry.addStructuralReader(AclIIds.ACLS_AP_INT_EGR_ACLS, AclSetsBuilder.class);
 
-        registry.addStructuralReader(ACL_EGRESS_IID, EgressBuilder.class);
-        registry.addAfter(new GenericInitListReader<>(ACL_EGRESS_IID.child(VppAcls.class),
-            new EgressVppAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID);
+        registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT_ING_ACLS_ACL,
+                        new IngressAclCustomizer(futureAclFacade, interfaceContext, standardAclContext, macIpAClContext)),
+                AclIIds.ACLS_AP_INT);
+        registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT_EGR_ACLS_ACL,
+                new EgressAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), AclIIds.ACLS_AP_INT);
     }
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java
index 377d4e1dc..1b590cb7b 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java
@@ -19,7 +19,7 @@ package io.fd.hc2vpp.acl.util;
 import io.fd.honeycomb.translate.MappingContext;
 import java.util.List;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
 
 /**
  * Manages metadata for acl plugin
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java
index aa25c3eb1..a96680897 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java
@@ -29,18 +29,18 @@ import java.util.List;
 import java.util.stream.Collector;
 import javax.annotation.Nonnull;
 import javax.annotation.concurrent.ThreadSafe;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.VppAclContextAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.VppAclMappings;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContext;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContextKey;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMapping;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingKey;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMapping;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingKey;
 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.Contexts;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.VppAclContextAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.VppAclMappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContext;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContextKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 
@@ -77,7 +77,7 @@ public final class AclContextManagerImpl implements AclContextManager {
         final List<AceMapping> mappings = new ArrayList<>(aces.size());
         int aceIndex = 0;
         for (final Ace ace : aces) {
-            mappings.add(new AceMappingBuilder().setName(ace.getRuleName()).setIndex(aceIndex++).build());
+            mappings.add(new AceMappingBuilder().setName(ace.getName()).setIndex(aceIndex++).build());
         }
         aclMapping.setAceMapping(mappings);
         ctx.put(mappingIid, aclMapping.build());
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java
index db5efb4d6..8e774104a 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java
@@ -16,6 +16,7 @@
 
 package io.fd.hc2vpp.acl.util.ace;
 
+import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.acl.util.ace.extractor.MacIpAceDataExtractor;
 import io.fd.hc2vpp.acl.util.ace.extractor.StandardAceDataExtractor;
@@ -27,16 +28,16 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceKey;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAceBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAceBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.MatchesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.EthBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.SourceNetwork;
 
 /**
  * Convert between Ace's and vpp rules.
@@ -45,23 +46,55 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr
 
     default MacipAclRule[] toMacIpAclRules(@Nonnull final List<Ace> aces) {
         return aces.stream()
+                .filter(ace -> ace.getMatches() != null && ace.getMatches().getL2() != null)
+                .filter(ace -> ace.getMatches().getL2().getImplementedInterface()
+                        .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth.class))
                 .map(ace -> {
-                    final VppMacipAce macIpAce = fromMacIpAce(ace);
-
                     MacipAclRule rule = new MacipAclRule();
+                    org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth
+                            l2 =
+                            (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth) ace
+                                    .getMatches().getL2();
+
+                    Eth eth = Preconditions
+                            .checkNotNull(l2.getEth(), "Cannot parse eth for MacIpAcl ACE rule: {}", ace);
 
-                    rule.srcMac = sourceMacAsBytes(macIpAce);
-                    rule.srcMacMask = sourceMacMaskAsBytes(macIpAce);
+                    rule.srcMac = sourceMacAsBytes(eth.getSourceMacAddress());
+                    rule.srcMacMask = sourceMacMaskAsBytes(eth.getSourceMacAddressMask());
                     rule.isPermit = macIpAction(ace);
 
-                    if (macIpIsIpv6(macIpAce)) {
-                        rule.isIpv6 = 1;
-                        rule.srcIpAddr = ipv6Address(macIpAce);
-                        rule.srcIpPrefixLen = ipv6AddressPrefix(macIpAce);
+                    L3 l3 = ace.getMatches().getL3();
+
+                    if (l3 != null && l3.getImplementedInterface()
+                            .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4.class)) {
+                        Ipv4 ipv4 =
+                                ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4) l3)
+                                        .getIpv4();
+                        if (ipv4 != null && ipv4.getSourceNetwork() != null) {
+                            // IPv4 is set for MacIpAcl
+                            SourceNetwork sourceNetwork = ipv4.getSourceNetwork();
+                            rule.isIpv6 = 0;
+                            rule.srcIpAddr = ipv4Address(sourceNetwork);
+                            rule.srcIpPrefixLen = ipv4AddressPrefix(sourceNetwork);
+                        }
+                    } else if (l3 != null && l3.getImplementedInterface()
+                            .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6.class)) {
+                        Ipv6 ipv6 =
+                                ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6) l3)
+                                        .getIpv6();
+                        if (ipv6 != null && ipv6.getSourceNetwork() != null) {
+                            // IPv6 is set for MacIpAcl
+                            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork
+                                    sourceNetwork = ipv6.getSourceNetwork();
+                            rule.isIpv6 = 1;
+                            rule.srcIpAddr = ipv6Address(sourceNetwork);
+                            rule.srcIpPrefixLen = ipv6AddressPrefix(sourceNetwork);
+                        }
                     } else {
+                        // No IP is set for MacIpAcl
                         rule.isIpv6 = 0;
-                        rule.srcIpAddr = ipv4Address(macIpAce);
-                        rule.srcIpPrefixLen = ipv4AddressPrefix(macIpAce);
+                        rule.srcIpAddr = new byte[4];
+                        rule.srcIpPrefixLen = 0;
                     }
 
                     return rule;
@@ -72,26 +105,25 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr
 
     default AclRule[] toStandardAclRules(@Nonnull final List<Ace> aces) {
         return aces.stream()
+                .filter(ace -> ace.getMatches() != null)
                 .map(ace -> {
-                    final VppAce standardAce = fromStandardAce(ace);
-
                     // pre-bind rule with protocol based attributes (if present)
-                    AclRule rule = createPreBindRule(standardAce);
+                    AclRule rule = createPreBindRule(ace);
 
                     rule.isPermit = standardAction(ace);
 
-                    if (standardIsIpv6(standardAce, ace.getMatches())) {
+                    if (standardIsIpv6(ace.getMatches())) {
                         rule.isIpv6 = 1;
-                        rule.srcIpAddr = ipv6SourceAddress(standardAce);
-                        rule.srcIpPrefixLen = ipv6SourceAddressPrefix(standardAce);
-                        rule.dstIpAddr = ipv6DestinationAddress(standardAce);
-                        rule.dstIpPrefixLen = ipv6DestinationAddressPrefix(standardAce);
+                        rule.srcIpAddr = ipv6SourceAddress(ace.getMatches());
+                        rule.srcIpPrefixLen = ipv6SourceAddressPrefix(ace.getMatches());
+                        rule.dstIpAddr = ipv6DestinationAddress(ace.getMatches());
+                        rule.dstIpPrefixLen = ipv6DestinationAddressPrefix(ace.getMatches());
                     } else {
                         rule.isIpv6 = 0;
-                        rule.srcIpAddr = ipv4SourceAddress(standardAce);
-                        rule.srcIpPrefixLen = ipv4SourceAddressPrefix(standardAce);
-                        rule.dstIpAddr = ipv4DestinationAddress(standardAce);
-                        rule.dstIpPrefixLen = ipv4DestinationAddressPrefix(standardAce);
+                        rule.srcIpAddr = ipv4SourceAddress(ace.getMatches());
+                        rule.srcIpPrefixLen = ipv4SourceAddressPrefix(ace.getMatches());
+                        rule.dstIpAddr = ipv4DestinationAddress(ace.getMatches());
+                        rule.dstIpPrefixLen = ipv4DestinationAddressPrefix(ace.getMatches());
                     }
 
                     return rule;
@@ -107,18 +139,20 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr
         int i = 0;
         for (final MacipAclRule rule : rules) {
             final AceBuilder ace = new AceBuilder();
-            final VppMacipAceBuilder aceType = new VppMacipAceBuilder();
-            final VppMacipAceNodesBuilder nodes = new VppMacipAceNodesBuilder();
-            nodes.setAceIpVersion(ipVersion(rule));
-            nodes.setSourceMacAddress(sourceMac(rule));
-            nodes.setSourceMacAddressMask(sourceMacMask(rule));
-            aceType.setVppMacipAceNodes(nodes.build());
-
-            ace.setMatches(new MatchesBuilder().setAceType(aceType.build()).build());
+            ace.setMatches(
+                    new MatchesBuilder()
+                            .setL3(parseMacIpAceL3(rule))
+                            .setL2(new EthBuilder()
+                                    .setEth(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.EthBuilder()
+                                            .setSourceMacAddress(sourceMac(rule))
+                                            .setSourceMacAddressMask(sourceMacMask(rule))
+                                            .build())
+                                    .build())
+                            .build());
             ace.setActions(actions(rule.isPermit));
 
             final String aceName = macipAclContext.getAceName(aclName, i++, mappingContext);
-            ace.setRuleName(aceName);
+            ace.setName(aceName);
             ace.withKey(new AceKey(aceName));
 
             aces.add(ace.build());
@@ -133,17 +167,14 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr
         int i = 0;
         for (final AclRule rule : rules) {
             final AceBuilder ace = new AceBuilder();
-            final VppAceBuilder aceType = new VppAceBuilder();
-            final VppAceNodesBuilder nodes = new VppAceNodesBuilder();
-            nodes.setAceIpVersion(ipVersion(rule));
-            nodes.setIpProtocol(parseProtocol(rule));
-            aceType.setVppAceNodes(nodes.build());
-
-            ace.setMatches(new MatchesBuilder().setAceType(aceType.build()).build());
+            ace.setMatches(new MatchesBuilder()
+                    .setL3(parseStandardAceL3(rule))
+                    .setL4(parseProtocol(rule))
+                    .build());
             ace.setActions(actions(rule.isPermit));
 
             final String aceName = standardAclContext.getAceName(aclName, i++, mappingContext);
-            ace.setRuleName(aceName);
+            ace.setName(aceName);
             ace.withKey(new AceKey(aceName));
             aces.add(ace.build());
         }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java
index ddb41ee3c..0c7d761a0 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java
@@ -21,84 +21,67 @@ import io.fd.hc2vpp.common.translate.util.MacTranslator;
 import io.fd.vpp.jvpp.acl.types.MacipAclRule;
 import java.util.Optional;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6Builder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.SourceNetwork;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceEthHeaderFields;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceIpv4HeaderFields;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceIpv6HeaderFields;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.AceIpVersion;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv4Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6Builder;
 
 public interface MacIpAceDataExtractor extends AddressExtractor, MacTranslator {
 
-    default VppMacipAce fromMacIpAce(@Nonnull final Ace ace) {
-        return Optional.ofNullable(ace.getMatches())
-                .map(Matches::getAceType)
-                .map(VppMacipAce.class::cast)
-                .orElseThrow(
-                        () -> new IllegalArgumentException(String.format("Unable to create VppMacipAce from %s", ace)));
-    }
-
-    default boolean macIpIsIpv6(@Nonnull final VppMacipAce ace) {
-        return Optional.ofNullable(ace.getVppMacipAceNodes())
-                .map(VppMacipAceNodes::getAceIpVersion)
-                .map(aceIpVersion -> aceIpVersion instanceof AceIpv6)
-                .orElse(false);
-    }
-
-    default byte[] sourceMacAsBytes(@Nonnull final VppMacipAce ace) {
-        return macToByteArray(Optional.ofNullable(ace.getVppMacipAceNodes())
-                .map(VppMacipAceEthHeaderFields::getSourceMacAddress)
+    default byte[] sourceMacAsBytes(final MacAddress mac) {
+        return macToByteArray(Optional.ofNullable(mac)
                 .map(MacAddress::getValue)
                 .orElse(Impl.DEFAULT_MAC));
     }
 
-    default byte[] sourceMacMaskAsBytes(@Nonnull final VppMacipAce ace) {
-        return macToByteArray(Optional.ofNullable(ace.getVppMacipAceNodes())
-                .map(VppMacipAceEthHeaderFields::getSourceMacAddressMask)
+    default byte[] sourceMacMaskAsBytes(final MacAddress mac) {
+        return macToByteArray(Optional.ofNullable(mac)
                 .map(MacAddress::getValue)
                 .orElse(Impl.DEFAULT_MAC_MASK));
     }
 
-    default byte[] ipv4Address(@Nonnull final VppMacipAce ace) {
-        return extractIp4Address(extractV4NetworkAddressOrNull(ace));
+    default byte[] ipv4Address(@Nonnull final SourceNetwork network) {
+        return extractIp4Address(extractV4NetworkAddressOrNull(network));
     }
 
-    default byte ipv4AddressPrefix(@Nonnull final VppMacipAce ace) {
-        return extractIp4AddressPrefix(extractV4NetworkAddressOrNull(ace));
+    default byte ipv4AddressPrefix(@Nonnull final SourceNetwork network) {
+        return extractIp4AddressPrefix(extractV4NetworkAddressOrNull(network));
     }
 
-    static Ipv4Prefix extractV4NetworkAddressOrNull(final @Nonnull VppMacipAce ace) {
-        return Optional.ofNullable(ace.getVppMacipAceNodes())
-                .map(VppMacipAceNodes::getAceIpVersion)
-                .map(VppMacipAceIpv4HeaderFields.class::cast)
-                .map(VppMacipAceIpv4HeaderFields::getSourceIpv4Network)
+    static Ipv4Prefix extractV4NetworkAddressOrNull(final @Nonnull SourceNetwork network) {
+        return Optional.of(network).filter(net -> net instanceof SourceIpv4Network)
+                .map(SourceIpv4Network.class::cast)
+                .map(SourceIpv4Network::getSourceIpv4Network)
                 .orElse(null);
     }
 
-    default byte[] ipv6Address(@Nonnull final VppMacipAce ace) {
-        return extractIp6Address(extractV6NetworkAddressOrNull(ace));
+    default byte[] ipv6Address(
+            @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) {
+        return extractIp6Address(extractV6NetworkAddressOrNull(network));
     }
 
-    default byte ipv6AddressPrefix(@Nonnull final VppMacipAce ace) {
-        return extractIp6AddressPrefix(extractV6NetworkAddressOrNull(ace));
+    default byte ipv6AddressPrefix(
+            @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) {
+        return extractIp6AddressPrefix(extractV6NetworkAddressOrNull(network));
     }
 
-    default Ipv6Prefix extractV6NetworkAddressOrNull(@Nonnull final VppMacipAce ace) {
-        return Optional.ofNullable(ace.getVppMacipAceNodes())
-                .map(VppMacipAceNodes::getAceIpVersion)
-                .map(VppMacipAceIpv6HeaderFields.class::cast)
-                .map(VppMacipAceIpv6HeaderFields::getSourceIpv6Network)
+    default Ipv6Prefix extractV6NetworkAddressOrNull(
+            @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) {
+        return Optional.of(network).filter(net -> net instanceof SourceIpv6Network)
+                .map(SourceIpv6Network.class::cast)
+                .map(SourceIpv6Network::getSourceIpv6Network)
                 .orElse(null);
     }
 
@@ -107,41 +90,54 @@ public interface MacIpAceDataExtractor extends AddressExtractor, MacTranslator {
      */
     default byte macIpAction(@Nonnull final Ace ace) {
         // action choice itself has default, but nothing stops us from not defining actions container itself
-        final PacketHandling action = Optional.ofNullable(ace.getActions()).orElseThrow(
-                () -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace)))
-                .getPacketHandling();
-        if (action instanceof Permit) {
-            return 1;
-        } else if (action instanceof Deny) {
-            return 0;
+        Actions actions = Optional.ofNullable(ace.getActions()).orElseThrow(
+                () -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace)));
+        if (actions.getForwarding() != null) {
+            if (ace.getActions().getForwarding().equals(Accept.class)) {
+                return 1;
+            } else {
+                return 0;
+            }
         } else {
             throw new IllegalArgumentException(
-                    String.format("Unsupported packet-handling action %s for ACE %s", action, ace));
+                    String.format("Unsupported packet-handling action %s for ACE %s", actions, ace));
         }
     }
 
-    default AceIpVersion ipVersion(@Nonnull final MacipAclRule rule) {
+    default L3 parseMacIpAceL3(@Nonnull final MacipAclRule rule) {
         if (rule.isIpv6 == 0) {
-            return ip4Ace(rule);
+            return ip4L3(rule);
         } else {
-            return ip6Ace(rule);
+            return ip6L3(rule);
         }
     }
 
-    default AceIpVersion ip4Ace(@Nonnull final MacipAclRule rule) {
-        final AceIpv4Builder ipVersion = new AceIpv4Builder();
+    default Ipv4 ip4L3(@Nonnull final MacipAclRule rule) {
+        final Ipv4Builder ipv4Builder = new Ipv4Builder();
+
         if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) {
-            ipVersion.setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen));
+            ipv4Builder.setIpv4(
+                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder()
+                            .setSourceNetwork(new SourceIpv4NetworkBuilder()
+                                    .setSourceIpv4Network(
+                                            toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen))
+                                    .build())
+                            .build());
         }
-        return ipVersion.build();
+        return ipv4Builder.build();
     }
 
-    default AceIpVersion ip6Ace(@Nonnull final MacipAclRule rule) {
-        final AceIpv6Builder ipVersion = new AceIpv6Builder();
+    default Ipv6 ip6L3(@Nonnull final MacipAclRule rule) {
+        final Ipv6Builder ipv6Builder = new Ipv6Builder();
         if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) {
-            ipVersion.setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen));
+            ipv6Builder.setIpv6(
+                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder()
+                            .setSourceNetwork(new SourceIpv6NetworkBuilder()
+                                    .setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen))
+                                    .build())
+                            .build());
         }
-        return ipVersion.build();
+        return ipv6Builder.build();
     }
 
     default MacAddress sourceMac(@Nonnull final MacipAclRule rule) {
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java
index 8f463aef5..9f454fd38 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java
@@ -24,147 +24,148 @@ import java.util.Map;
 import java.util.Optional;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Actions;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AcceptAndReflect;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Drop;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.ForwardingAction;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Reject;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.ActionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6Builder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.AclIpv4HeaderFields;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.AclIpv6HeaderFields;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.AclIpProtocolHeaderFields;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.Stateful;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.StatefulBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.AceIpVersion;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv4Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclIpv4HeaderFields;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclIpv6HeaderFields;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4NetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6NetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder;
 
 public interface StandardAceDataExtractor extends AddressExtractor, ProtoPreBindRuleProducer, IpProtocolReader {
 
     /**
      * Allowed packet-processing actions for Acl's
      */
-    Map<Class<? extends PacketHandling>, Integer> ACTION_VALUE_PAIRS = ImmutableMap.of(Deny.class, 0, Permit.class, 1,
-            Stateful.class, 2);
-
-    default VppAce fromStandardAce(@Nonnull final Ace ace) {
-        return Optional.ofNullable(ace.getMatches())
-                .map(Matches::getAceType)
-                .map(VppAce.class::cast)
-                .orElseThrow(() -> new IllegalArgumentException(String.format("Unable to create VppAce from %s", ace)));
-    }
-
-    default boolean standardIsIpv6(@Nonnull final VppAce ace, @Nullable final Matches matches) {
-        final Optional<AceIpVersion> aceIpVersion = Optional.ofNullable(matches)
-                .map(Matches::getAceType)
-                .map(VppAce.class::cast)
-                .map(VppAce::getVppAceNodes)
-                .map(VppAceNodes::getAceIpVersion);
-
-        // tries to detect version by ace-ip-version
-        if(aceIpVersion.isPresent()){
-            return aceIpVersion
-                    .map(version -> version instanceof AceIpv6)
-                    .orElse(false);
-        }
+    Map<Class<? extends ForwardingAction>, Integer> ACTION_VALUE_PAIRS =
+            ImmutableMap.of(Drop.class, 0, Reject.class, 0, Accept.class, 1, AcceptAndReflect.class, 2);
 
-        // otherwise goes by ip-protocol
-        return Optional.ofNullable(ace.getVppAceNodes())
-                .map(AclIpProtocolHeaderFields::getIpProtocol)
-                .map(ipProtocol -> ipProtocol instanceof IcmpV6)
-                .orElse(false);
+    default boolean standardIsIpv6(@Nullable final Matches matches) {
+        return Optional.ofNullable(matches)
+                .map(Matches::getL3)
+                .filter(l3 -> l3.getImplementedInterface().equals(Ipv6.class))
+                .map(Ipv6.class::cast)
+                .map(Ipv6::getIpv6)
+                .isPresent();
     }
 
-    default byte[] ipv4SourceAddress(@Nonnull final VppAce ace) {
-        return extractIp4Address(
-                extractV4SourceAddressOrNull(ace));
+    default byte[] ipv4SourceAddress(@Nonnull final Matches matches) {
+        return extractIp4Address(extractV4SourceAddressOrNull(matches));
     }
 
-    default byte ipv4SourceAddressPrefix(@Nonnull final VppAce ace) {
-        return extractIp4AddressPrefix(
-                extractV4SourceAddressOrNull(ace));
+    default byte ipv4SourceAddressPrefix(@Nonnull final Matches matches) {
+        return extractIp4AddressPrefix(extractV4SourceAddressOrNull(matches));
     }
 
-    static Ipv4Prefix extractV4SourceAddressOrNull(@Nonnull final VppAce ace) {
-        return Optional.ofNullable(ace.getVppAceNodes())
-                .map(VppAceNodes::getAceIpVersion)
-                .map(AclIpv4HeaderFields.class::cast)
-                .map(AclIpv4HeaderFields::getSourceIpv4Network)
+    static Ipv4Prefix extractV4SourceAddressOrNull(@Nonnull final Matches matches) {
+        return getIpv4Optional(matches)
+                .map(AclIpv4HeaderFields::getSourceNetwork)
+                .filter(network -> network instanceof SourceIpv4Network)
+                .map(SourceIpv4Network.class::cast)
+                .map(SourceIpv4Network::getSourceIpv4Network)
                 .orElse(null);
     }
 
 
-    default byte[] ipv4DestinationAddress(@Nonnull final VppAce ace) {
-        return extractIp4Address(extractV4DestinationAddressOrNull(ace));
+    default byte[] ipv4DestinationAddress(@Nonnull final Matches matches) {
+        return extractIp4Address(extractV4DestinationAddressOrNull(matches));
     }
 
-    default byte ipv4DestinationAddressPrefix(@Nonnull final VppAce ace) {
-        return extractIp4AddressPrefix(extractV4DestinationAddressOrNull(ace));
+    default byte ipv4DestinationAddressPrefix(@Nonnull final Matches matches) {
+        return extractIp4AddressPrefix(extractV4DestinationAddressOrNull(matches));
     }
 
-    static Ipv4Prefix extractV4DestinationAddressOrNull(@Nonnull final VppAce ace) {
-        return Optional.ofNullable(ace.getVppAceNodes())
-                .map(VppAceNodes::getAceIpVersion)
-                .map(AclIpv4HeaderFields.class::cast)
-                .map(AclIpv4HeaderFields::getDestinationIpv4Network)
+    static Ipv4Prefix extractV4DestinationAddressOrNull(@Nonnull final Matches matches) {
+        return getIpv4Optional(matches)
+                .map(AclIpv4HeaderFields::getDestinationNetwork)
+                .filter(destinationNetwork -> destinationNetwork instanceof DestinationIpv4Network)
+                .map(DestinationIpv4Network.class::cast)
+                .map(DestinationIpv4Network::getDestinationIpv4Network)
                 .orElse(null);
     }
 
-    default byte[] ipv6SourceAddress(@Nonnull final VppAce ace) {
-        return extractIp6Address(extractV6SourceAddressOrNull(ace));
+    static Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4> getIpv4Optional(
+            @Nonnull final Matches matches) {
+        return Optional.ofNullable(matches.getL3())
+                .filter(l3 -> l3.getImplementedInterface().equals(Ipv4.class))
+                .map(Ipv4.class::cast)
+                .map(Ipv4::getIpv4);
+    }
+
+    default byte[] ipv6SourceAddress(@Nonnull final Matches matches) {
+        return extractIp6Address(extractV6SourceAddressOrNull(matches));
     }
 
-    default byte ipv6SourceAddressPrefix(@Nonnull final VppAce ace) {
-        return extractIp6AddressPrefix(extractV6SourceAddressOrNull(ace));
+    default byte ipv6SourceAddressPrefix(@Nonnull final Matches matches) {
+        return extractIp6AddressPrefix(extractV6SourceAddressOrNull(matches));
     }
 
-    static Ipv6Prefix extractV6SourceAddressOrNull(@Nonnull final VppAce ace) {
-        return Optional.ofNullable(ace.getVppAceNodes())
-                .map(VppAceNodes::getAceIpVersion)
-                .map(AclIpv6HeaderFields.class::cast)
-                .map(AclIpv6HeaderFields::getSourceIpv6Network)
+    static Ipv6Prefix extractV6SourceAddressOrNull(@Nonnull final Matches matches) {
+        return getIpv6Optional(matches)
+                .map(AclIpv6HeaderFields::getSourceNetwork)
+                .filter(sourceNetwork -> sourceNetwork instanceof SourceIpv6Network)
+                .map(SourceIpv6Network.class::cast)
+                .map(SourceIpv6Network::getSourceIpv6Network)
                 .orElse(null);
     }
 
-    default byte[] ipv6DestinationAddress(@Nonnull final VppAce ace) {
-        return extractIp6Address(extractV6DestinationAddressOrNull(ace));
+    default byte[] ipv6DestinationAddress(@Nonnull final Matches matches) {
+        return extractIp6Address(extractV6DestinationAddressOrNull(matches));
     }
 
-    default byte ipv6DestinationAddressPrefix(@Nonnull final VppAce ace) {
-        return extractIp6AddressPrefix(extractV6DestinationAddressOrNull(ace));
+    default byte ipv6DestinationAddressPrefix(@Nonnull final Matches matches) {
+        return extractIp6AddressPrefix(extractV6DestinationAddressOrNull(matches));
     }
 
-    static Ipv6Prefix extractV6DestinationAddressOrNull(@Nonnull final VppAce ace) {
-        return Optional.ofNullable(ace.getVppAceNodes())
-                .map(VppAceNodes::getAceIpVersion)
-                .map(AclIpv6HeaderFields.class::cast)
-                .map(AclIpv6HeaderFields::getDestinationIpv6Network)
+    static Ipv6Prefix extractV6DestinationAddressOrNull(@Nonnull final Matches matches) {
+        return getIpv6Optional(matches)
+                .map(AclIpv6HeaderFields::getDestinationNetwork)
+                .filter(destinationNetwork -> destinationNetwork instanceof DestinationIpv6Network)
+                .map(DestinationIpv6Network.class::cast)
+                .map(DestinationIpv6Network::getDestinationIpv6Network)
                 .orElse(null);
     }
 
+    static Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6> getIpv6Optional(
+            @Nonnull final Matches matches) {
+        return Optional.ofNullable(matches.getL3())
+                .filter(l3 -> l3.getImplementedInterface().equals(Ipv6.class))
+                .map(Ipv6.class::cast)
+                .map(Ipv6::getIpv6);
+    }
+
     default byte standardAction(@Nonnull final Ace ace) {
-        // default == deny
-        final PacketHandling action = Optional.ofNullable(ace.getActions())
+        Class<? extends ForwardingAction> forwarding = Optional.ofNullable(ace.getActions())
                 .orElseThrow(() -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace)))
-                .getPacketHandling();
+                .getForwarding();
         return ACTION_VALUE_PAIRS.get(ACTION_VALUE_PAIRS.keySet().stream()
-                .filter(aClass -> aClass.isInstance(action))
+                .filter(aClass -> aClass.equals(forwarding))
                 .findAny()
                 .orElseThrow(() -> new IllegalArgumentException(
-                        String.format("Unsupported packet-handling action %s for ACE %s", action,
-                                ace.getRuleName())))).byteValue();
+                        String.format("Unsupported packet-handling action %s for ACE %s", forwarding,
+                                ace.getName())))).byteValue();
     }
 
-    default AceIpVersion ipVersion(@Nonnull final AclRule rule) {
+    default L3 parseStandardAceL3(@Nonnull final AclRule rule) {
         if (rule.isIpv6 == 0) {
             return ip4Ace(rule);
         } else {
@@ -172,40 +173,55 @@ public interface StandardAceDataExtractor extends AddressExtractor, ProtoPreBind
         }
     }
 
-    default AceIpVersion ip4Ace(@Nonnull final AclRule rule) {
-        final AceIpv4Builder ipVersion = new AceIpv4Builder();
+    default org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4 ip4Ace(
+            @Nonnull final AclRule rule) {
+        Ipv4Builder ipv4Builder = new Ipv4Builder();
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder
+                ip4Builder =
+                new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder();
         if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) {
-            ipVersion.setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen));
+            ip4Builder.setSourceNetwork(new SourceIpv4NetworkBuilder()
+                    .setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen))
+                    .build());
         }
         if (rule.dstIpAddr != null && rule.dstIpAddr.length != 0) {
-            ipVersion.setDestinationIpv4Network(toIpv4Prefix(truncateIp4Array(rule.dstIpAddr), rule.dstIpPrefixLen));
+            ip4Builder.setDestinationNetwork(new DestinationIpv4NetworkBuilder()
+                    .setDestinationIpv4Network(toIpv4Prefix(truncateIp4Array(rule.dstIpAddr), rule.dstIpPrefixLen))
+                    .build());
         }
-        return ipVersion.build();
+        return ipv4Builder.setIpv4(ip4Builder.build()).build();
     }
 
-    default AceIpVersion ip6Ace(@Nonnull final AclRule rule) {
-        final AceIpv6Builder ipVersion = new AceIpv6Builder();
+    default org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6 ip6Ace(
+            @Nonnull final AclRule rule) {
+        Ipv6Builder ipv6Builder = new Ipv6Builder();
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder
+                ip6Builder =
+                new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder();
+
         if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) {
-            ipVersion.setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen));
+            ip6Builder.setSourceNetwork(new SourceIpv6NetworkBuilder()
+                    .setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen))
+                    .build());
         }
         if (rule.dstIpAddr != null && rule.dstIpAddr.length != 0) {
-            ipVersion.setDestinationIpv6Network(toIpv6Prefix(rule.dstIpAddr, rule.dstIpPrefixLen));
+            ip6Builder.setDestinationNetwork(new DestinationIpv6NetworkBuilder()
+                    .setDestinationIpv6Network(toIpv6Prefix(rule.dstIpAddr, rule.dstIpPrefixLen))
+                    .build());
         }
-        return ipVersion.build();
+        return ipv6Builder.setIpv6(ip6Builder.build()).build();
     }
 
     default Actions actions(final byte isPermit) {
         final ActionsBuilder actions = new ActionsBuilder();
         switch (isPermit) {
             case 0:
-                actions.setPacketHandling(new DenyBuilder().setDeny(true).build());
+                actions.setForwarding(Drop.class);
                 break;
             case 1:
-                actions.setPacketHandling(new PermitBuilder().setPermit(true).build());
-                break;
-            case 2:
-                actions.setPacketHandling(new StatefulBuilder().setPermitAndReflect(true).build());
+                actions.setForwarding(Accept.class);
                 break;
+
             default:
                 throw new IllegalArgumentException("Unsupported action: " + isPermit);
         }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java
index 5f75ae306..977dd4062 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java
@@ -16,16 +16,19 @@
 
 package io.fd.hc2vpp.acl.util.acl;
 
+import com.google.common.base.Preconditions;
+import io.fd.hc2vpp.acl.write.AclValidator;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Optional;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAcl;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppMacipAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Ipv4AclType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
 
 /**
  * Extracts data from Acls.
@@ -34,31 +37,25 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.
 public interface AclDataExtractor {
 
     /**
-     * Checks if provided {@link Acl} has aces of type {@link VppAce}
+     * Checks if provided {@link Acl} has aces of type {@link Ipv4AclType} or {@link VppAcl}
      */
     default boolean isStandardAcl(@Nonnull final Acl acl) {
-        return acl.getAccessListEntries().getAce().stream()
-                .map(Ace::getMatches)
-                .map(Matches::getAceType)
-                .filter(aceType -> aceType instanceof VppAce)
-                .findAny()
-                .isPresent();
+        Class<? extends AclBase> type =
+                Preconditions.checkNotNull(acl.getType(), "Type is not set for ACL:{}", acl);
+        return type.equals(VppAcl.class);
     }
 
     /**
-     * Checks if provided {@link Acl} has aces of type {@link VppMacipAce}
+     * Checks if provided {@link Acl} has aces of type {@link VppMacipAcl}
      */
     default boolean isMacIpAcl(@Nonnull final Acl acl) {
-        return acl.getAccessListEntries().getAce().stream()
-                .map(Ace::getMatches)
-                .map(Matches::getAceType)
-                .filter(aceType -> aceType instanceof VppMacipAce)
-                .findAny()
-                .isPresent();
+        Class<? extends AclBase> type =
+                Preconditions.checkNotNull(acl.getType(), "Type is not set for ACL:{}", acl);
+        return type.equals(VppMacipAcl.class);
     }
 
     default List<Ace> getAces(@Nonnull final Acl acl) {
-        return Optional.ofNullable(acl.getAccessListEntries()).orElseThrow(() ->
+        return Optional.ofNullable(acl.getAces()).orElseThrow(() ->
                 new IllegalArgumentException(String.format("Unable to extract aces from %s", acl))).getAce();
     }
 
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java
deleted file mode 100644
index 474a52844..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2017 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.util.factory;
-
-import com.google.common.collect.ImmutableSet;
-import java.util.Set;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntries;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Actions;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.other.OtherNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodes;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public interface AclFactory {
-
-    default Set<InstanceIdentifier<?>> vppAclChildren(final InstanceIdentifier<Acl> parentId) {
-        final InstanceIdentifier<Matches> matchesIid =
-            parentId.child(AccessListEntries.class).child(Ace.class).child(Matches.class);
-        return ImmutableSet.of(
-            parentId.augmentation(VppAclAugmentation.class),
-            parentId.child(AccessListEntries.class),
-            parentId.child(AccessListEntries.class).child(Ace.class),
-            parentId.child(AccessListEntries.class).child(Ace.class).child(Matches.class),
-            parentId.child(AccessListEntries.class).child(Ace.class).child(Actions.class),
-            matchesIid,
-            matchesIid.child(VppMacipAceNodes.class),
-            matchesIid.child(VppAceNodes.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpNodes.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpNodes.class).child(IcmpCodeRange.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpNodes.class).child(IcmpTypeRange.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class).child(IcmpCodeRange.class),
-            matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class).child(IcmpTypeRange.class),
-            matchesIid.child(VppAceNodes.class).child(UdpNodes.class),
-            matchesIid.child(VppAceNodes.class).child(UdpNodes.class).child(SourcePortRange.class),
-            matchesIid.child(VppAceNodes.class).child(UdpNodes.class).child(DestinationPortRange.class),
-            matchesIid.child(VppAceNodes.class).child(TcpNodes.class),
-            matchesIid.child(VppAceNodes.class).child(TcpNodes.class).child(SourcePortRange.class),
-            matchesIid.child(VppAceNodes.class).child(TcpNodes.class).child(DestinationPortRange.class),
-            matchesIid.child(VppAceNodes.class).child(OtherNodes.class)
-
-        );
-    }
-
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java
index 9c8b99b45..3207ecd4b 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java
@@ -21,40 +21,42 @@ import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.ICMP_INDEX
 import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.TCP_INDEX;
 import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.UDP_INDEX;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.fd.vpp.jvpp.acl.types.AclRule;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRange;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRangeBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRange;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRangeBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.icmp.icmp.VppIcmpAceBuilder;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.tcp.tcp.VppTcpAceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.IcmpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.TcpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.UdpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.DestinationPortBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.SourcePortBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.source.port.RangeOrOperatorBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRangeBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRangeBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.IpProtocol;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Icmp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.OtherBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Tcp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.TcpBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Udp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.UdpBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6NodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.other.OtherNodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclTcpHeaderFields;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.PortRangeOrOperator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.Range;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.RangeBuilder;
 
 /**
  * Utility for parsing IpProtocol DO based on data returned by vpp as {@link AclRule}.
  */
 public interface IpProtocolReader {
 
-    default IpProtocol parseProtocol(final AclRule rule) {
+    default L4 parseProtocol(final AclRule rule) {
         switch (rule.proto) {
+            case ICMPV6_INDEX:
             case ICMP_INDEX: {
                 return Impl.parseIcmp(rule);
             }
@@ -66,14 +68,8 @@ public interface IpProtocolReader {
             case UDP_INDEX: {
                 return Impl.parseUdp(rule);
             }
-
-            case ICMPV6_INDEX: {
-                return Impl.parseIcmp6(rule);
-            }
-            default: {
-                return Impl.parse(rule);
-            }
         }
+        return null;
     }
 
     class Impl {
@@ -91,51 +87,107 @@ public interface IpProtocolReader {
         }
 
         private static Icmp parseIcmp(final AclRule rule) {
-            final IcmpNodesBuilder nodes = new IcmpNodesBuilder();
-            nodes.setIcmpCodeRange(parseIcmpCodeRange(rule));
-            nodes.setIcmpTypeRange(parseIcmpTypeRange(rule));
-            return new IcmpBuilder().setIcmpNodes(nodes.build()).build();
+            return new IcmpBuilder().setIcmp(
+                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.IcmpBuilder()
+                            .addAugmentation(VppIcmpAceAugmentation.class,
+                                    new VppIcmpAceAugmentationBuilder()
+                                            .setVppIcmpAce(new VppIcmpAceBuilder()
+                                                    .setIcmpCodeRange(parseIcmpCodeRange(rule))
+                                                    .setIcmpTypeRange(parseIcmpTypeRange(rule))
+                                                    .build())
+                                            .build())
+                            .build())
+                    .build();
         }
 
-        private static DestinationPortRange parseDstPortRange(final AclRule rule) {
-            return new DestinationPortRangeBuilder()
-                .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeFirst)))
-                .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeLast))).build();
+        private static PortRangeOrOperator parseDstPortRange(final AclRule rule) {
+            return new RangeBuilder()
+                    .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeFirst)))
+                    .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeLast))).build();
         }
 
-        private static SourcePortRange parseSrcPortRange(final AclRule rule) {
-            return new SourcePortRangeBuilder()
+        private static Range parseSrcPortRange(final AclRule rule) {
+            return new RangeBuilder()
                 .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.srcportOrIcmptypeFirst)))
                 .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.srcportOrIcmptypeLast))).build();
         }
 
         private static Tcp parseTcp(final AclRule rule) {
-            final TcpNodesBuilder nodes = new TcpNodesBuilder();
-            nodes.setDestinationPortRange(parseDstPortRange(rule));
-            nodes.setSourcePortRange(parseSrcPortRange(rule));
-            nodes.setTcpFlagsMask((short) Byte.toUnsignedInt(rule.tcpFlagsMask));
-            nodes.setTcpFlagsValue((short) Byte.toUnsignedInt(rule.tcpFlagsValue));
-            return new TcpBuilder().setTcpNodes(nodes.build()).build();
+            return new TcpBuilder().setTcp(
+                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.TcpBuilder()
+                            .setFlags(parseTcpFlags((short) Byte.toUnsignedInt(rule.tcpFlagsValue)))
+                            .addAugmentation(VppTcpAceAugmentation.class, new VppTcpAceAugmentationBuilder()
+                                    .setVppTcpAce(new VppTcpAceBuilder()
+                                            .setFlagsMask(
+                                                    parseTcpFlagsMask((short) Byte.toUnsignedInt(rule.tcpFlagsMask)))
+                                            .build())
+                                    .build())
+                            .setSourcePort(new SourcePortBuilder()
+                                    .setSourcePort(new RangeOrOperatorBuilder()
+                                            .setPortRangeOrOperator(parseSrcPortRange(rule))
+                                            .build())
+                                    .build())
+                            .setDestinationPort(new DestinationPortBuilder()
+                                    .setDestinationPort(
+                                            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperatorBuilder()
+                                                    .setPortRangeOrOperator(parseDstPortRange(rule))
+                                                    .build())
+                                    .build())
+                            .build())
+                    .build();
         }
 
-        private static Udp parseUdp(final AclRule rule) {
-            final UdpNodesBuilder nodes = new UdpNodesBuilder();
-            nodes.setDestinationPortRange(parseDstPortRange(rule));
-            nodes.setSourcePortRange(parseSrcPortRange(rule));
-            return new UdpBuilder().setUdpNodes(nodes.build()).build();
+        @VisibleForTesting
+        private static org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask parseTcpFlagsMask(
+                final short tcpFlagsMask) {
+            // Flags from bit on position 1 to 8
+            final Boolean cwr = (tcpFlagsMask & 0b00000001) == 1;
+            final Boolean ece = (tcpFlagsMask & 0b00000010) >> 1 == 1;
+            final Boolean urg = (tcpFlagsMask & 0b00000100) >> 2 == 1;
+            final Boolean ack = (tcpFlagsMask & 0b00001000) >> 3 == 1;
+            final Boolean psh = (tcpFlagsMask & 0b00010000) >> 4 == 1;
+            final Boolean rst = (tcpFlagsMask & 0b00100000) >> 5 == 1;
+            final Boolean syn = (tcpFlagsMask & 0b01000000) >> 6 == 1;
+            final Boolean fin = (tcpFlagsMask & 0b10000000) >> 7 == 1;
+
+            return new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask(
+                    ack, cwr, ece, fin, psh, rst, syn, urg);
         }
 
-        private static IcmpV6 parseIcmp6(final AclRule rule) {
-            final IcmpV6NodesBuilder nodes = new IcmpV6NodesBuilder();
-            nodes.setIcmpCodeRange(parseIcmpCodeRange(rule));
-            nodes.setIcmpTypeRange(parseIcmpTypeRange(rule));
-            return new IcmpV6Builder().setIcmpV6Nodes(nodes.build()).build();
+        @VisibleForTesting
+        private static AclTcpHeaderFields.Flags parseTcpFlags(final short tcpFlagsValue) {
+            // Flags from bit on position 1 to 8
+            final Boolean cwr = (tcpFlagsValue & 0b00000001) == 1;
+            final Boolean ece = (tcpFlagsValue & 0b00000010) >> 1 == 1;
+            final Boolean urg = (tcpFlagsValue & 0b00000100) >> 2 == 1;
+            final Boolean ack = (tcpFlagsValue & 0b00001000) >> 3 == 1;
+            final Boolean psh = (tcpFlagsValue & 0b00010000) >> 4 == 1;
+            final Boolean rst = (tcpFlagsValue & 0b00100000) >> 5 == 1;
+            final Boolean syn = (tcpFlagsValue & 0b01000000) >> 6 == 1;
+            final Boolean fin = (tcpFlagsValue & 0b10000000) >> 7 == 1;
+
+            return new AclTcpHeaderFields.Flags(ack, cwr, ece, fin, psh, rst, syn, urg);
         }
 
-        private static Other parse(final AclRule rule) {
-            final OtherNodesBuilder nodes = new OtherNodesBuilder();
-            nodes.setProtocol((short) Short.toUnsignedInt(rule.proto));
-            return new OtherBuilder().setOtherNodes(nodes.build()).build();
+        private static Udp parseUdp(final AclRule rule) {
+            return new UdpBuilder().setUdp(
+                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.UdpBuilder()
+                            .setSourcePort(
+                                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.SourcePortBuilder()
+                                            .setSourcePort(
+                                                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperatorBuilder()
+                                                            .setPortRangeOrOperator(parseSrcPortRange(rule))
+                                                            .build())
+                                            .build())
+                            .setDestinationPort(
+                                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.DestinationPortBuilder()
+                                            .setDestinationPort(
+                                                    new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperatorBuilder()
+                                                            .setPortRangeOrOperator(parseDstPortRange(rule))
+                                                            .build())
+                                            .build())
+                            .build())
+                    .build();
         }
     }
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java
index 582da0357..3ca18d6e6 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java
@@ -16,31 +16,27 @@
 
 package io.fd.hc2vpp.acl.util.protocol;
 
-import static com.google.common.base.Preconditions.checkArgument;
-import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.ProtocolPair.pair;
-
-import com.google.common.collect.ImmutableSet;
+import com.google.common.base.Preconditions;
 import io.fd.vpp.jvpp.acl.types.AclRule;
-import java.util.Optional;
-import java.util.Set;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.ValueRange;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.Icmp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.Tcp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.DestinationPort;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.SourcePort;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.source.port.RangeOrOperator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.Udp;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.ValueRange;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.IpProtocol;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Icmp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Tcp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Udp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodes;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclTcpHeaderFields;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.PortRangeOrOperator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.Range;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
 
 /**
  * Creates ACL rules pre-bind with protocol-related fields.<br>
@@ -53,89 +49,41 @@ public interface ProtoPreBindRuleProducer {
     int TCP_INDEX = 6;
     int UDP_INDEX = 17;
     int ICMPV6_INDEX = 58;
-    short MAX_PORT_NUMBER = (short)65535;
-
-    Set<ProtocolPair> PROTOCOL_PAIRS = ImmutableSet.of(pair(Icmp.class, ICMP_INDEX), pair(Tcp.class, TCP_INDEX),
-            pair(Udp.class, UDP_INDEX), pair(IcmpV6.class, ICMPV6_INDEX));
-
-    class ProtocolPair {
-        private final Class<? extends IpProtocol> protocolClass;
-        private final int index;
+    short MAX_PORT_NUMBER = (short) 65535;
 
-        private ProtocolPair(final Class<? extends IpProtocol> protocolClass, final int index) {
-            this.protocolClass = protocolClass;
-            this.index = index;
-        }
-
-        static ProtocolPair pair(@Nonnull final Class<? extends IpProtocol> protocolClass, @Nonnull final int index) {
-            return new ProtocolPair(protocolClass, index);
-        }
+    static AclRule bindIcmpVppFields(AclRule rule, Icmp icmp) {
+        VppIcmpAceAugmentation vppIcmp = icmp.augmentation(VppIcmpAceAugmentation.class);
+        Preconditions.checkNotNull(vppIcmp.getVppIcmpAce(), "Cannot determine VPP ICMP attributes!");
+        final ValueRange typesRange = vppIcmp.getVppIcmpAce().getIcmpTypeRange();
+        final ValueRange codesRange = vppIcmp.getVppIcmpAce().getIcmpCodeRange();
 
-        boolean match(@Nonnull final Class<? extends IpProtocol> protocolClass) {
-            return this.protocolClass.isAssignableFrom(protocolClass);
+        if (typesRange != null) {
+            rule.srcportOrIcmptypeFirst = Preconditions.checkNotNull(typesRange.getFirst());
+            rule.srcportOrIcmptypeLast = Preconditions.checkNotNull(typesRange.getLast());
         }
 
-        int getIndex() {
-            return this.index;
+        if (codesRange != null) {
+            rule.dstportOrIcmpcodeFirst = Preconditions.checkNotNull(codesRange.getFirst());
+            rule.dstportOrIcmpcodeLast = Preconditions.checkNotNull(codesRange.getLast());
         }
-    }
-
-    static byte protocol(final IpProtocol ipProtocol) {
-        final Optional<ProtocolPair> optPair = PROTOCOL_PAIRS.stream()
-                .filter(protocolPair -> protocolPair.match(ipProtocol.getClass()))
-                .findAny();
-
-        if (!optPair.isPresent()) {
-            if (Other.class.isAssignableFrom(ipProtocol.getClass())) {
-                return Other.class.cast(ipProtocol).getOtherNodes().getProtocol().byteValue();
-            }
-
-            throw new IllegalArgumentException(String.format("Unsupported Protocol Type %s", ipProtocol.getClass()));
-        }
-        return (byte) optPair.get().getIndex();
-    }
-
-    static AclRule bindIcmpNodes(AclRule rule, VppAce ace) {
-        final VppAceNodes vppAceNodes = ace.getVppAceNodes();
-        checkArgument(vppAceNodes.getIpProtocol() instanceof Icmp);
-        final IcmpNodes icmp = Icmp.class.cast(vppAceNodes.getIpProtocol()).getIcmpNodes();
-        final ValueRange typesRange = icmp.getIcmpTypeRange();
-        final ValueRange codesRange = icmp.getIcmpCodeRange();
-
-        rule.srcportOrIcmptypeFirst = typesRange.getFirst();
-        rule.srcportOrIcmptypeLast = typesRange.getLast();
-        rule.dstportOrIcmpcodeFirst = codesRange.getFirst();
-        rule.dstportOrIcmpcodeLast = codesRange.getLast();
 
         return rule;
     }
 
-    static AclRule bindIcmpv6Nodes(AclRule rule, VppAce ace) {
-        final VppAceNodes vppAceNodes = ace.getVppAceNodes();
-        checkArgument(vppAceNodes.getIpProtocol() instanceof IcmpV6);
-        final IcmpV6Nodes icmpV6 = IcmpV6.class.cast(vppAceNodes.getIpProtocol()).getIcmpV6Nodes();
-        final ValueRange typesRange = icmpV6.getIcmpTypeRange();
-        final ValueRange codesRange = icmpV6.getIcmpCodeRange();
-
-        rule.srcportOrIcmptypeFirst = typesRange.getFirst();
-        rule.srcportOrIcmptypeLast = typesRange.getLast();
-        rule.dstportOrIcmpcodeFirst = codesRange.getFirst();
-        rule.dstportOrIcmpcodeLast = codesRange.getLast();
-
-        return rule;
-    }
-
-    static void bindSourcePortRange(@Nonnull final AclRule rule, @Nullable final SourcePortRange sourcePortRange) {
+    static void bindSourcePortRange(@Nonnull final AclRule rule, @Nullable final PortRangeOrOperator sourcePortRange) {
         // allow all ports by default:
         rule.srcportOrIcmptypeFirst = 0;
         rule.srcportOrIcmptypeLast = MAX_PORT_NUMBER;
 
-        if(sourcePortRange != null) {
+        if (sourcePortRange != null) {
             // lower port is mandatory
-            rule.srcportOrIcmptypeFirst = portNumber(sourcePortRange.getLowerPort());
+            Preconditions.checkArgument(sourcePortRange instanceof Range);
+            Range portRange = (Range) sourcePortRange;
+            Preconditions.checkNotNull(portRange.getLowerPort(), "Lower port is mandatory!");
+            rule.srcportOrIcmptypeFirst = portNumber(portRange.getLowerPort());
 
-            if (sourcePortRange.getUpperPort() != null) {
-                rule.srcportOrIcmptypeLast = portNumber(sourcePortRange.getUpperPort());
+            if (portRange.getUpperPort() != null) {
+                rule.srcportOrIcmptypeLast = portNumber(portRange.getUpperPort());
             } else {
                 // if upper port is missing, set lower port value as end of checked range:
                 rule.srcportOrIcmptypeLast = rule.srcportOrIcmptypeFirst;
@@ -143,17 +91,21 @@ public interface ProtoPreBindRuleProducer {
         }
     }
 
-    static void bindDestinationPortRange(@Nonnull final AclRule rule, @Nullable final DestinationPortRange destinationPortRange) {
+    static void bindDestinationPortRange(@Nonnull final AclRule rule,
+                                         @Nullable final PortRangeOrOperator destinationPortRange) {
         // allow all ports by default:
         rule.dstportOrIcmpcodeFirst = 0;
         rule.dstportOrIcmpcodeLast = MAX_PORT_NUMBER;
 
-        if(destinationPortRange != null) {
+        if (destinationPortRange != null) {
             // lower port is mandatory
-            rule.dstportOrIcmpcodeFirst = portNumber(destinationPortRange.getLowerPort());
+            Preconditions.checkArgument(destinationPortRange instanceof Range);
+            Range portRange = (Range) destinationPortRange;
+            Preconditions.checkNotNull(portRange.getLowerPort(), "Lower port is mandatory!");
+            rule.dstportOrIcmpcodeFirst = portNumber(portRange.getLowerPort());
 
-            if (destinationPortRange.getUpperPort() != null) {
-                rule.dstportOrIcmpcodeLast = portNumber(destinationPortRange.getUpperPort());
+            if (portRange.getUpperPort() != null) {
+                rule.dstportOrIcmpcodeLast = portNumber(portRange.getUpperPort());
             } else {
                 // if upper port is missing, set lower port value as end of checked range:
                 rule.dstportOrIcmpcodeLast = rule.dstportOrIcmpcodeFirst;
@@ -161,30 +113,78 @@ public interface ProtoPreBindRuleProducer {
         }
     }
 
-    static AclRule bindTcpNodes(AclRule rule, VppAce ace) {
-        final VppAceNodes vppAceNodes = ace.getVppAceNodes();
-        checkArgument(vppAceNodes.getIpProtocol() instanceof Tcp);
+    static AclRule bindTcpAttributes(AclRule rule, Tcp tcp) {
+        SourcePort srcPort = Preconditions.checkNotNull(tcp.getSourcePort()).getSourcePort();
+        if (srcPort instanceof RangeOrOperator) {
+            bindSourcePortRange(rule, ((RangeOrOperator) srcPort).getPortRangeOrOperator());
+        }
 
-        final TcpNodes tcp = Tcp.class.cast(vppAceNodes.getIpProtocol()).getTcpNodes();
-        bindSourcePortRange(rule, tcp.getSourcePortRange());
-        bindDestinationPortRange(rule, tcp.getDestinationPortRange());
+        DestinationPort dstPort = Preconditions.checkNotNull(tcp.getDestinationPort()).getDestinationPort();
+        if (dstPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) {
+            bindDestinationPortRange(rule,
+                    ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) dstPort)
+                            .getPortRangeOrOperator());
+        }
+        AclTcpHeaderFields.Flags flags = tcp.getFlags();
 
-        if(tcp.getTcpFlagsMask() != null) {
-            rule.tcpFlagsMask = tcp.getTcpFlagsMask().byteValue();
+        if (flags != null) {
+            rule.tcpFlagsValue = parseTcpFlagsValue(flags);
         }
-        if(tcp.getTcpFlagsValue() != null) {
-            rule.tcpFlagsValue = tcp.getTcpFlagsValue().byteValue();
+
+        VppTcpAceAugmentation vppTcpAceAugmentation = tcp.augmentation(VppTcpAceAugmentation.class);
+        if (vppTcpAceAugmentation != null && vppTcpAceAugmentation.getVppTcpAce() != null &&
+                vppTcpAceAugmentation.getVppTcpAce().getFlagsMask() != null) {
+            rule.tcpFlagsMask = parseTcpFlagsMask(vppTcpAceAugmentation.getVppTcpAce().getFlagsMask());
         }
+
         return rule;
     }
 
-    static AclRule bindUdpNodes(AclRule rule, VppAce ace) {
-        final VppAceNodes vppAceNodes = ace.getVppAceNodes();
-        checkArgument(vppAceNodes.getIpProtocol() instanceof Udp);
+    static byte parseTcpFlagsValue(AclTcpHeaderFields.Flags flags) {
+        int fin = flags.isFin() ? 1 : 0;
+        int syn = flags.isSyn() ? 1 : 0;
+        int rst = flags.isRst() ? 1 : 0;
+        int psh = flags.isPsh() ? 1 : 0;
+        int ack = flags.isAck() ? 1 : 0;
+        int urg = flags.isUrg() ? 1 : 0;
+        int ece = flags.isEce() ? 1 : 0;
+        int cwr = flags.isCwr() ? 1 : 0;
+        String strFlags = String.format("%d%d%d%d%d%d%d%d", fin, syn, rst, psh, ack, urg, ece, cwr);
+        return Byte.parseByte(strFlags, 2);
+    }
+
+    static byte parseTcpFlagsMask(
+            org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask flags) {
+        int fin = flags.isFin() ? 1 : 0;
+        int syn = flags.isSyn() ? 1 : 0;
+        int rst = flags.isRst() ? 1 : 0;
+        int psh = flags.isPsh() ? 1 : 0;
+        int ack = flags.isAck() ? 1 : 0;
+        int urg = flags.isUrg() ? 1 : 0;
+        int ece = flags.isEce() ? 1 : 0;
+        int cwr = flags.isCwr() ? 1 : 0;
+        String strFlags = String.format("%d%d%d%d%d%d%d%d", fin, syn, rst, psh, ack, urg, ece, cwr);
+        return Byte.parseByte(strFlags, 2);
+    }
+
+    static AclRule bindUdpAttributes(AclRule rule, Udp udp) {
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.SourcePort
+                srcPort = Preconditions.checkNotNull(udp.getSourcePort()).getSourcePort();
+
+        if (srcPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) {
+            bindSourcePortRange(rule,
+                    ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) srcPort)
+                            .getPortRangeOrOperator());
+        }
+
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.DestinationPort
+                dstPort = Preconditions.checkNotNull(udp.getDestinationPort()).getDestinationPort();
 
-        final UdpNodes udp = Udp.class.cast(vppAceNodes.getIpProtocol()).getUdpNodes();
-        bindSourcePortRange(rule, udp.getSourcePortRange());
-        bindDestinationPortRange(rule, udp.getDestinationPortRange());
+        if (dstPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) {
+            bindDestinationPortRange(rule,
+                    ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) dstPort)
+                            .getPortRangeOrOperator());
+        }
         return rule;
     }
 
@@ -208,39 +208,56 @@ public interface ProtoPreBindRuleProducer {
      * @param vppAce rule to be processed
      * @return AclRule with protocol filled protocol fields
      */
-    default AclRule createPreBindRule(@Nonnull final VppAce vppAce) {
+    default AclRule createPreBindRule(@Nonnull final Ace vppAce) {
         AclRule rule = new AclRule();
 
-
-        final IpProtocol ipProtocol = vppAce.getVppAceNodes().getIpProtocol();
-        if (ipProtocol == null) {
+        L4 l4 = Preconditions.checkNotNull(vppAce.getMatches(), "Matches are not defined for ACE: {}!", vppAce).getL4();
+        if (l4 == null) {
             // returns AclRule with rule.proto set to 0 (protocol fields will be ignored by vpp)
             return rule;
         }
 
-        rule.proto = protocol(ipProtocol);
-
-        switch (rule.proto) {
-            case ICMP_INDEX: {
-                return bindIcmpNodes(rule, vppAce);
-            }
-
-            case TCP_INDEX: {
-                return bindTcpNodes(rule, vppAce);
-            }
-
-            case UDP_INDEX: {
-                return bindUdpNodes(rule, vppAce);
-            }
+        if (l4.getImplementedInterface()
+                .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp.class)) {
+            return getIcmpAclRule(vppAce, rule,
+                    (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp) l4);
+        } else if (l4.getImplementedInterface()
+                .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp.class)) {
+            return getTcpAclRule(rule,
+                    (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp) l4);
+        } else if (l4.getImplementedInterface()
+                .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp.class)) {
+            return getUdpAclRule(rule,
+                    (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp) l4);
+        } else {
+            return bindDefaultNodes(rule);
+        }
+    }
 
-            case ICMPV6_INDEX: {
-                return bindIcmpv6Nodes(rule, vppAce);
-            }
-            default: {
-                return bindDefaultNodes(rule);
-            }
+    default AclRule getIcmpAclRule(@Nonnull final Ace vppAce, final AclRule rule,
+                                   final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp l4) {
+        if (vppAce.getMatches().getL3() == null) {
+            rule.proto = ICMP_INDEX;
+        } else {
+            Class<? extends DataContainer> ipVersion = vppAce.getMatches().getL3().getImplementedInterface();
+            rule.proto = (byte) (ipVersion.equals(Ipv6.class) ? ICMPV6_INDEX : ICMP_INDEX);
         }
 
+        Icmp icmp = l4.getIcmp();
+        return icmp != null ? bindIcmpVppFields(rule, icmp) : bindDefaultNodes(rule);
     }
 
+    default AclRule getUdpAclRule(final AclRule rule,
+                                  final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp l4) {
+        rule.proto = UDP_INDEX;
+        Udp udp = l4.getUdp();
+        return udp != null ? bindUdpAttributes(rule, udp) : bindDefaultNodes(rule);
+    }
+
+    default AclRule getTcpAclRule(final AclRule rule,
+                                  final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp l4) {
+        rule.proto = TCP_INDEX;
+        Tcp tcp = l4.getTcp();
+        return tcp != null ? bindTcpAttributes(rule, tcp) : bindDefaultNodes(rule);
+    }
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclCustomizer.java
index 00cd8a56c..1161c09ef 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclCustomizer.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclCustomizer.java
@@ -19,26 +19,25 @@ package io.fd.hc2vpp.acl.write;
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
 import io.fd.hc2vpp.acl.util.acl.AclDataExtractor;
-import io.fd.hc2vpp.acl.util.acl.AclWriter;
-import io.fd.honeycomb.translate.MappingContext;
+import io.fd.hc2vpp.acl.write.request.AclAddReplaceRequest;
 import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.honeycomb.translate.write.WriteFailedException;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
-public class VppAclCustomizer extends FutureJVppAclCustomizer
-        implements ListWriterCustomizer<Acl, AclKey>, AclDataExtractor, AclWriter {
+public class AclCustomizer extends FutureJVppAclCustomizer
+        implements ListWriterCustomizer<Acl, AclKey>, AclDataExtractor {
 
     private final AclContextManager standardAclContext;
     private final AclContextManager macIpAclContext;
 
-    public VppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                            @Nonnull final AclContextManager standardAclContext,
-                            @Nonnull final AclContextManager macIpAclContext) {
+    public AclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
+                         @Nonnull final AclContextManager standardAclContext,
+                         @Nonnull final AclContextManager macIpAclContext) {
         super(jVppAclFacade);
         this.standardAclContext = standardAclContext;
         this.macIpAclContext = macIpAclContext;
@@ -47,12 +46,11 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer
     @Override
     public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataAfter,
                                        @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        final MappingContext mappingContext = writeContext.getMappingContext();
-
+        AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext());
         if (isStandardAcl(dataAfter)) {
-            addStandardAcl(getjVppAclFacade(), id, dataAfter, standardAclContext, mappingContext);
+            request.addStandardAcl(id, dataAfter, standardAclContext);
         } else if (isMacIpAcl(dataAfter)) {
-            addMacIpAcl(getjVppAclFacade(), id, dataAfter, macIpAclContext, mappingContext);
+            request.addMacIpAcl(id, dataAfter, macIpAclContext);
         } else {
             // double check, first one done by validation
             throw new WriteFailedException.CreateFailedException(id, dataAfter,
@@ -64,17 +62,17 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer
     public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
                                         @Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext)
             throws WriteFailedException {
-        final MappingContext mappingContext = writeContext.getMappingContext();
+        AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext());
 
         if (isStandardAcl(dataAfter)) {
-            updateStandardAcl(getjVppAclFacade(), id, dataAfter, standardAclContext, mappingContext);
+            request.updateStandardAcl(id, dataAfter, standardAclContext);
         } else if (isMacIpAcl(dataAfter)) {
             synchronized (macIpAclContext) {
                 // there is no direct support for update of mac-ip acl, but only one is allowed per interface
                 // so it is atomic from vpp standpoint. Enclosed in synchronized block to prevent issues with
                 // multiple threads managing naming context
-                deleteMacIpAcl(getjVppAclFacade(), id, dataBefore, macIpAclContext, mappingContext);
-                addMacIpAcl(getjVppAclFacade(), id, dataAfter, macIpAclContext, mappingContext);
+                request.deleteMacIpAcl(id, dataBefore, macIpAclContext);
+                request.addMacIpAcl(id, dataAfter, macIpAclContext);
             }
         } else {
             // double check, first one done by validation
@@ -86,12 +84,12 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer
     @Override
     public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
                                         @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        final MappingContext mappingContext = writeContext.getMappingContext();
+        AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext());
 
         if (isStandardAcl(dataBefore)) {
-            deleteStandardAcl(getjVppAclFacade(), id, dataBefore, standardAclContext, mappingContext);
+            request.deleteStandardAcl(id, dataBefore, standardAclContext);
         } else if (isMacIpAcl(dataBefore)) {
-            deleteMacIpAcl(getjVppAclFacade(), id, dataBefore, macIpAclContext, mappingContext);
+            request.deleteMacIpAcl(id, dataBefore, macIpAclContext);
         } else {
             // double check, first one done by validation
             throw new WriteFailedException.DeleteFailedException(id,
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java
new file mode 100644
index 000000000..b7aaebcff
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.write;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.fd.hc2vpp.acl.AclIIds;
+import io.fd.hc2vpp.acl.util.acl.AclDataExtractor;
+import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException;
+import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException;
+import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException;
+import io.fd.honeycomb.translate.write.Validator;
+import io.fd.honeycomb.translate.write.WriteContext;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAcl;
+import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppMacipAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPoints;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.Aces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public final class AclValidator implements Validator<Acl>, AclDataExtractor {
+
+    private static final Set<Class<? extends AclBase>> SUPPORTED_ACL_TYPES =
+            ImmutableSet.of(VppAcl.class, VppMacipAcl.class);
+
+    @Override
+    public void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx)
+            throws CreateValidationFailedException {
+        try {
+            validateAcl(dataAfter);
+        } catch (RuntimeException e) {
+            throw new CreateValidationFailedException(id, dataAfter, e);
+        }
+    }
+
+    @Override
+    public void validateUpdate(final InstanceIdentifier<Acl> id, final Acl dataBefore, final Acl dataAfter,
+                               final WriteContext ctx) throws UpdateValidationFailedException {
+        try {
+            validateAcl(dataAfter);
+        } catch (RuntimeException e) {
+            throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e);
+        }
+    }
+
+    @Override
+    public void validateDelete(final InstanceIdentifier<Acl> id, final Acl dataBefore, final WriteContext ctx)
+            throws DeleteValidationFailedException {
+        try {
+            validateAcl(dataBefore);
+            final List<String> references = checkAclReferenced(ctx, dataBefore);
+            // references must be check, to not leave dead references in configuration
+            checkState(references.isEmpty(),
+                    "%s cannot be removed, it is referenced in following interfaces %s", dataBefore, references);
+        } catch (RuntimeException e) {
+            throw new DeleteValidationFailedException(id, e);
+        }
+    }
+
+    private static void validateAcl(@Nonnull final Acl acl) {
+        hasAceList(acl);
+        isSupportedAclType(acl);
+        hasConsistentAceTypeForAclType(acl);
+    }
+
+    private static void hasAceList(final Acl acl) {
+        final Aces accessListEntries = acl.getAces();
+        checkArgument(accessListEntries != null, "The access-list-entries container is not defined.");
+        final List<Ace> ace = accessListEntries.getAce();
+        checkArgument(ace != null, "The ace list is not defined.");
+        checkArgument(!ace.isEmpty(), "The ace list is empty.");
+    }
+
+    private static void isSupportedAclType(final Acl acl) {
+        checkArgument(SUPPORTED_ACL_TYPES.contains(acl.getType()),
+                "Unsupported Acl type %s detected for acl %s, allowed types are %s", acl.getType(),
+                acl.getName(), SUPPORTED_ACL_TYPES);
+    }
+
+    private static void hasConsistentAceTypeForAclType(final Acl acl) {
+        Class<? extends AclBase> type = acl.getType();
+        Preconditions.checkNotNull(type, "Cannot resolve Acl type for validation of Acl: {}", acl);
+        Preconditions.checkNotNull(acl.getAces(), "ACEs are missing for validation of Acl: {}", acl);
+        Preconditions.checkNotNull(acl.getAces().getAce(), "List of ACEs is null for validation of Acl: {}", acl);
+        if (type.equals(VppAcl.class)) {
+            Set<Ace> unsupportedVppAcls =
+                    acl.getAces().getAce().stream().filter(ace -> !isVppAce(ace)).collect(Collectors.toSet());
+            checkArgument(unsupportedVppAcls.isEmpty(), "Detected unsupported ace types [%s] for ACL %s",
+                    unsupportedVppAcls, acl.getName());
+        }
+
+        if (type.equals(VppMacipAcl.class)) {
+            Set<Ace> unsupportedVppMacipAclAcls =
+                    acl.getAces().getAce().stream().filter(ace -> !isVppMacipAclAce(ace)).collect(Collectors.toSet());
+            checkArgument(unsupportedVppMacipAclAcls.isEmpty(), "Detected unsupported ace types [%s] for ACL %s",
+                    unsupportedVppMacipAclAcls, acl.getName());
+        }
+    }
+
+    private static boolean isVppMacipAclAce(final Ace ace) {
+        Matches matches = Preconditions
+                .checkNotNull(ace.getMatches(), "Cannot validate VppMacipAcl type for Ace: {}, matches are not defined",
+                        ace);
+        if (matches.getL2() == null || !(matches.getL2() instanceof Eth)) {
+            return false;
+        }
+
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth
+                eth = ((Eth) matches.getL2()).getEth();
+        if (eth == null) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static boolean isVppAce(final Ace ace) {
+        Matches matches = Preconditions
+                .checkNotNull(ace.getMatches(), "Cannot validate VppMacipAcl type for Ace: {}, matches are not defined",
+                        ace);
+        L3 l3 = matches.getL3();
+        if (l3 == null || (!(l3 instanceof Ipv4)) && (!(l3 instanceof Ipv6))) {
+            return false;
+        }
+
+        if (l3 instanceof Ipv4) {
+            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4
+                    ipv4 = ((Ipv4) l3).getIpv4();
+            if (ipv4 == null || ipv4.getSourceNetwork() == null ||
+                    !(ipv4.getSourceNetwork() instanceof SourceIpv4Network)) {
+                return false;
+            }
+        }
+
+        if (l3 instanceof Ipv6) {
+            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6
+                    ipv6 = ((Ipv6) l3).getIpv6();
+            if (ipv6 == null || ipv6.getSourceNetwork() == null ||
+                    !(ipv6.getSourceNetwork() instanceof SourceIpv6Network)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @VisibleForTesting
+    static List<String> checkAclReferenced(@Nonnull final WriteContext writeContext, @Nonnull final Acl acl) {
+        Preconditions.checkNotNull(acl.getType(), "Cannot validate acl: {}, type is not set.", acl);
+        if (!acl.getType().equals(VppAcl.class) && !acl.getType().equals(VppMacipAcl.class)) {
+            throw new IllegalArgumentException(String.format("Acl type %s not supported", acl.getType()));
+        }
+
+        Optional<AttachmentPoints> attachmentPointsOpt = writeContext.readAfter(AclIIds.ACLS_AP);
+        if (!attachmentPointsOpt.isPresent() || attachmentPointsOpt.get().getInterface() == null) {
+            return Collections.emptyList();
+        }
+
+        final List<Interface> interfaces = attachmentPointsOpt.get().getInterface();
+        if (interfaces == null) {
+            return Collections.emptyList();
+        }
+        final String aclName = acl.getName();
+
+        HashMap<String, AclSets> sets = getIngressAclSets(interfaces);
+        sets.putAll(getEgressAclSets(interfaces));
+        List<String> referencedIfcs = new ArrayList<>();
+        sets.forEach((ifc, aclSets) -> {
+            if (aclSets.getAclSet() != null) {
+                if (aclSets.getAclSet().stream()
+                        .map(AclSet::getName)
+                        .filter(Objects::nonNull)
+                        .anyMatch(name -> name.equalsIgnoreCase(aclName))) {
+                    referencedIfcs.add(ifc);
+                }
+            }
+        });
+        return referencedIfcs.stream().distinct().collect(Collectors.toList());
+    }
+
+    private static HashMap<String, AclSets> getEgressAclSets(final List<Interface> interfaces) {
+        HashMap<String, AclSets> map = new HashMap<>();
+        interfaces.stream().filter(anInterface -> anInterface.getEgress() != null)
+                .forEach(anInterface -> map.put(anInterface.getInterfaceId(), anInterface.getEgress().getAclSets()));
+        return map;
+    }
+
+    private static HashMap<String, AclSets> getIngressAclSets(final List<Interface> interfaces) {
+        HashMap<String, AclSets> map = new HashMap<>();
+        interfaces.stream().filter(anInterface -> anInterface.getIngress() != null)
+                .forEach(anInterface -> map.put(anInterface.getInterfaceId(), anInterface.getIngress().getAclSets()));
+        return map;
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java
index a6ca35af3..622a84d93 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java
@@ -16,82 +16,177 @@
 
 package io.fd.hc2vpp.acl.write;
 
+import static io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest.deleteExisting;
 import static java.util.stream.Collectors.toList;
 
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
-import io.fd.hc2vpp.acl.util.iface.acl.AclInterfaceAssignmentRequest;
+import io.fd.hc2vpp.acl.write.request.AclInterfaceAssignmentRequest;
+import io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.MappingContext;
 import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.honeycomb.translate.write.WriteFailedException;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclsBaseAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 /**
  * Handles acl assignments(only standard ones, mac-ip have dedicated customizer)
  */
-public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<Acl> {
+public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<Interface> {
 
     private final NamingContext interfaceContext;
     private final AclContextManager standardAclContext;
+    private final AclContextManager macIpAclContext;
 
     public InterfaceAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
                                   @Nonnull final NamingContext interfaceContext,
-                                  @Nonnull final AclContextManager standardAclContext) {
+                                  @Nonnull final AclContextManager standardAclContext,
+                                  @Nonnull final AclContextManager macIpAclContext) {
         super(jVppAclFacade);
         this.interfaceContext = interfaceContext;
         this.standardAclContext = standardAclContext;
+        this.macIpAclContext = macIpAclContext;
+    }
+
+    private static List<String> getAclNames(final AclSets acls) {
+        if (acls == null || acls.getAclSet() == null) {
+            return Collections.emptyList();
+        } else {
+            return acls.getAclSet().stream().map(AclSet::getName).collect(toList());
+        }
     }
 
     @Override
-    public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataAfter,
+    public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
+                                       @Nonnull final Interface dataAfter,
                                        @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        AclInterfaceAssignmentRequest.create(writeContext.getMappingContext())
-                .standardAclContext(standardAclContext)
-                .interfaceContext(interfaceContext)
-                .identifier(id)
-                .inputAclNames(getAclNames(dataAfter.getIngress()))
-                .outputAclNames(getAclNames(dataAfter.getEgress()))
-                .executeAsCreate(getjVppAclFacade());
+        AclSets egress = dataAfter.getEgress() != null ? dataAfter.getEgress().getAclSets() : null;
+        AclSets ingress = dataAfter.getIngress() != null ? dataAfter.getIngress().getAclSets() : null;
+        List<String> macIngress = parseMacRules(getAclNames(ingress), writeContext.getMappingContext());
+        List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext());
+        List<String> standardEgress = parseStandardRules(getAclNames(egress), writeContext.getMappingContext());
+
+        // Process standard ACLs
+        if (!standardIngress.isEmpty() || !standardEgress.isEmpty()) {
+            AclInterfaceAssignmentRequest.create(writeContext.getMappingContext())
+                    .standardAclContext(standardAclContext)
+                    .interfaceContext(interfaceContext)
+                    .identifier(id)
+                    .inputAclNames(standardIngress)
+                    .outputAclNames(standardEgress)
+                    .executeAsCreate(getjVppAclFacade());
+        }
+        // Process mac ACLs
+        if (!macIngress.isEmpty()) {
+            addMacAcls(id, writeContext, macIngress);
+        }
     }
 
     @Override
-    public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
-                                        @Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext)
+    public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
+                                        @Nonnull final Interface dataBefore,
+                                        @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext)
             throws WriteFailedException {
+        AclSets egress = dataAfter.getEgress() != null ? dataAfter.getEgress().getAclSets() : null;
+        AclSets ingress = dataAfter.getIngress() != null ? dataAfter.getIngress().getAclSets() : null;
+        List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext());
+        List<String> standardEgress = parseStandardRules(getAclNames(egress), writeContext.getMappingContext());
+
+        // update standard ACLs
         AclInterfaceAssignmentRequest.create(writeContext.getMappingContext())
                 .standardAclContext(standardAclContext)
                 .interfaceContext(interfaceContext)
                 .identifier(id)
-                .inputAclNames(getAclNames(dataAfter.getIngress()))
-                .outputAclNames(getAclNames(dataAfter.getEgress()))
+                .inputAclNames(standardIngress)
+                .outputAclNames(standardEgress)
                 .executeAsUpdate(getjVppAclFacade(), dataBefore, dataAfter);
+
+        // Process mac ACLs
+        AclSets ingressBefore = dataBefore.getIngress() != null ? dataBefore.getIngress().getAclSets() : null;
+        List<String> macIngressAfter = parseMacRules(getAclNames(ingress), writeContext.getMappingContext());
+        List<String> macIngressBefore = parseMacRules(getAclNames(ingressBefore), writeContext.getMappingContext());
+        List<String> added =
+                macIngressAfter.stream().filter(acl -> !macIngressBefore.contains(acl)).collect(Collectors.toList());
+        List<String> removed =
+                macIngressBefore.stream().filter(acl -> !macIngressAfter.contains(acl)).collect(Collectors.toList());
+
+        if (!removed.isEmpty()) {
+            deleteMacACLs(id, writeContext, removed);
+        }
+
+        if (!added.isEmpty()) {
+            addMacAcls(id, writeContext, added);
+        }
     }
 
     @Override
-    public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
-                                        @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        AclInterfaceAssignmentRequest.create(writeContext.getMappingContext())
-                .standardAclContext(standardAclContext)
-                .interfaceContext(interfaceContext)
-                .identifier(id)
-                .executeAsDelete(getjVppAclFacade());
+    public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
+                                        @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext)
+            throws WriteFailedException {
+        AclSets ingress = dataBefore.getIngress() != null ? dataBefore.getIngress().getAclSets() : null;
+        List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext());
+        List<String> macIngress = parseMacRules(getAclNames(ingress), writeContext.getMappingContext());
+
+        //Process standard ACLs
+        if (!standardIngress.isEmpty()) {
+            AclInterfaceAssignmentRequest.create(writeContext.getMappingContext())
+                    .standardAclContext(standardAclContext)
+                    .interfaceContext(interfaceContext)
+                    .identifier(id)
+                    .executeAsDelete(getjVppAclFacade());
+        }
+
+        // Process mac ACLs
+        if (!macIngress.isEmpty()) {
+            deleteMacACLs(id, writeContext, macIngress);
+        }
     }
 
-    private static List<String> getAclNames(final VppAclsBaseAttributes acls) {
-        if (acls == null || acls.getVppAcls() == null) {
-            return Collections.emptyList();
-        } else {
-            return acls.getVppAcls().stream().map(VppAcls::getName).collect(toList());
+    private List<String> parseMacRules(final List<String> ingress, final MappingContext mappingContext) {
+        return ingress.stream()
+                .filter(aclName -> macIpAclContext.containsAcl(aclName, mappingContext)).collect(Collectors.toList());
+    }
+
+    private List<String> parseStandardRules(final List<String> ingress, final MappingContext mappingContext) {
+        return ingress.stream()
+                .filter(aclName -> standardAclContext.containsAcl(aclName, mappingContext))
+                .collect(Collectors.toList());
+    }
+
+
+    private void addMacAcls(@Nonnull final InstanceIdentifier<Interface> id,
+                            @Nonnull final WriteContext writeContext, final List<String> added)
+            throws WriteFailedException {
+        for (String macAcl : added) {
+            MacIpInterfaceAssignmentRequest.addNew(writeContext.getMappingContext())
+                    .identifier(id)
+                    .aclName(macAcl)
+                    .macIpAclContext(macIpAclContext)
+                    .interfaceContext(interfaceContext)
+                    .execute(getjVppAclFacade());
         }
     }
 
+    private void deleteMacACLs(@Nonnull final InstanceIdentifier<Interface> id,
+                               @Nonnull final WriteContext writeContext, final List<String> macAcls)
+            throws WriteFailedException {
+        for (String macAcl : macAcls) {
+            deleteExisting(writeContext.getMappingContext())
+                    .identifier(id)
+                    .aclName(macAcl)
+                    .macIpAclContext(macIpAclContext)
+                    .interfaceContext(interfaceContext)
+                    .execute(getjVppAclFacade());
+        }
+    }
 
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java
deleted file mode 100644
index fc0acd223..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.write;
-
-import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.addNew;
-import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.deleteExisting;
-
-import io.fd.hc2vpp.acl.util.AclContextManager;
-import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class InterfaceAclMacIpCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<VppMacipAcl> {
-
-    private final AclContextManager macIpAclContext;
-    private final NamingContext interfaceContext;
-
-    public InterfaceAclMacIpCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
-                                       @Nonnull final AclContextManager macIpAclContext,
-                                       @Nonnull final NamingContext interfaceContext) {
-        super(jVppAclFacade);
-        this.macIpAclContext = macIpAclContext;
-        this.interfaceContext = interfaceContext;
-    }
-
-    @Override
-    public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
-                                       @Nonnull final VppMacipAcl dataAfter,
-                                       @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        addNew(writeContext.getMappingContext())
-                .identifier(id)
-                .aclName(dataAfter.getName())
-                .macIpAclContext(macIpAclContext)
-                .interfaceContext(interfaceContext)
-                .execute(getjVppAclFacade());
-    }
-
-    @Override
-    public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id,
-                                        @Nonnull final VppMacipAcl dataBefore,
-                                        @Nonnull final WriteContext writeContext) throws WriteFailedException {
-        deleteExisting(writeContext.getMappingContext())
-                .identifier(id)
-                .aclName(dataBefore.getName())
-                .macIpAclContext(macIpAclContext)
-                .interfaceContext(interfaceContext)
-                .execute(getjVppAclFacade());
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java
deleted file mode 100644
index 942d3bcb3..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright (c) 2018 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.write;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static java.lang.String.format;
-import static java.util.Collections.emptyList;
-import static java.util.Optional.ofNullable;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.acl.util.acl.AclDataExtractor;
-import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException;
-import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException;
-import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException;
-import io.fd.honeycomb.translate.write.Validator;
-import io.fd.honeycomb.translate.write.WriteContext;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntries;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.AceType;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.InterfaceAclAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclsBaseAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppMacipAclsBaseAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public final class VppAclValidator implements Validator<Acl>, AclDataExtractor {
-
-    private static final Set<Class<? extends AclBase>> SUPPORTED_ACL_TYPES =
-        ImmutableSet.of(VppAcl.class, VppMacipAcl.class);
-    private static final Map<Class<? extends AclBase>, Class<? extends AceType>> ACL_ACE_PAIRS =
-        ImmutableMap.of(VppAcl.class, VppAce.class, VppMacipAcl.class, VppMacipAce.class);
-
-    @Override
-    public void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx)
-        throws CreateValidationFailedException {
-        try {
-            validateAcl(dataAfter);
-        } catch (RuntimeException e) {
-            throw new CreateValidationFailedException(id, dataAfter, e);
-        }
-    }
-
-    @Override
-    public void validateUpdate(final InstanceIdentifier<Acl> id, final Acl dataBefore, final Acl dataAfter,
-                               final WriteContext ctx) throws UpdateValidationFailedException {
-        try {
-            validateAcl(dataAfter);
-        } catch (RuntimeException e) {
-            throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e);
-        }
-    }
-
-    @Override
-    public void validateDelete(final InstanceIdentifier<Acl> id, final Acl dataBefore, final WriteContext ctx)
-        throws DeleteValidationFailedException {
-        try {
-            validateAcl(dataBefore);
-            final List<Interface> references = checkAclReferenced(ctx, dataBefore);
-            // references must be check, to not leave dead references in configuration
-            checkState(references.isEmpty(),
-                "%s cannot be removed, it is referenced in following interfaces %s", dataBefore, references);
-        } catch (RuntimeException e) {
-            throw new DeleteValidationFailedException(id, e);
-        }
-    }
-
-    private static void validateAcl(@Nonnull final Acl acl) {
-        hasAceList(acl);
-        isSupportedAclType(acl);
-        hasConsistentAceTypeForAclType(acl);
-    }
-
-    private static void hasAceList(final Acl acl) {
-        final AccessListEntries accessListEntries = acl.getAccessListEntries();
-        checkArgument(accessListEntries != null, "The access-list-entries container is not defined.");
-        final List<Ace> ace = accessListEntries.getAce();
-        checkArgument(ace != null, "The ace list is not defined.");
-        checkArgument(!ace.isEmpty(), "The ace list is empty.");
-    }
-
-    private static void isSupportedAclType(final Acl acl) {
-        checkArgument(SUPPORTED_ACL_TYPES.contains(acl.getAclType()),
-            "Unsupported Acl type %s detected for acl %s, allowed types are %s", acl.getAclType(),
-            acl.getAclName(), SUPPORTED_ACL_TYPES);
-    }
-
-    private static void hasConsistentAceTypeForAclType(final Acl acl) {
-        checkTypesSame(acl.getAccessListEntries().getAce(), acl.getAclName(),
-            checkNotNull(ACL_ACE_PAIRS.get(acl.getAclType()), "Unsupported ACL type %s for ACL %s",
-                acl.getAclType(), acl.getAclName()));
-    }
-
-    private static void checkTypesSame(final List<Ace> aces, final String aclName,
-                                       final Class<? extends AceType> aceType) {
-        final Set<AceType> unsupportedAceTypes = aces.stream()
-            .map(Ace::getMatches)
-            .map(Matches::getAceType)
-            .filter(aceType::equals)
-            .collect(Collectors.toSet());
-        checkArgument(unsupportedAceTypes.isEmpty(), "Detected unsupported ace types [%s] for ACL %s, expected %s",
-            unsupportedAceTypes, aclName, aceType);
-    }
-
-    @VisibleForTesting
-    static List<Interface> checkAclReferenced(@Nonnull final WriteContext writeContext,
-                                              @Nonnull final Acl acl) {
-        final Optional<Interfaces> readAfter = writeContext.readAfter(InstanceIdentifier.create(Interfaces.class));
-        if (!readAfter.isPresent() || readAfter.get().getInterface() == null) {
-            return Collections.emptyList();
-        }
-
-        final List<Interface> interfaces = readAfter.get().getInterface();
-        final Class<? extends AclBase> aclType = acl.getAclType();
-        final String aclName = acl.getAclName();
-
-        if (aclType.equals(VppAcl.class)) {
-            return interfaces.stream()
-                .filter(iface -> ofNullable(iface.augmentation(VppAclInterfaceAugmentation.class))
-                    .map(InterfaceAclAttributes::getAcl)
-                    .filter(references ->
-                        checkVppAcls(references.getIngress(), aclName) ||
-                            checkVppAcls(references.getEgress(), aclName)).isPresent()
-                ).collect(Collectors.toList());
-        } else if (aclType.equals(VppMacipAcl.class)) {
-            return interfaces.stream()
-                .filter(iface -> ofNullable(iface.augmentation(VppAclInterfaceAugmentation.class))
-                    .map(InterfaceAclAttributes::getAcl)
-                    .map(aclAttr -> aclAttr.getIngress())
-                    .map(VppMacipAclsBaseAttributes::getVppMacipAcl)
-                    .filter(vppMacipAcl -> vppMacipAcl.getName().equals(aclName))
-                    .isPresent())
-                .collect(Collectors.toList());
-        } else {
-            throw new IllegalArgumentException(format("Acl type %s not supported", aclType));
-        }
-    }
-
-    private static boolean checkVppAcls(@Nullable final VppAclsBaseAttributes attrs, @Nonnull final String name) {
-        return ofNullable(attrs).map(VppAclsBaseAttributes::getVppAcls)
-            .orElse(emptyList())
-            .stream().anyMatch(acl -> acl.getName().equals(name));
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java
index 37a8de2d1..8944e5977 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java
@@ -26,10 +26,10 @@ import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 /**
  * Created by jsrnicek on 12.12.2016.
  */
-class AbstractAclWriterFactory {
+abstract class AbstractAclWriterFactory {
 
     @Inject
-    protected FutureJVppAclFacade futureAclFacade;
+    FutureJVppAclFacade futureAclFacade;
 
     @Inject
     @Named(AclModule.STANDARD_ACL_CONTEXT_NAME)
@@ -37,7 +37,7 @@ class AbstractAclWriterFactory {
 
     @Inject
     @Named(AclModule.MAC_IP_ACL_CONTEXT_NAME)
-    protected AclContextManager macIpAClContext;
+    protected AclContextManager macIpAclContext;
 
     @Inject
     @Named("interface-context")
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java
new file mode 100644
index 000000000..faab3023d
--- /dev/null
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.acl.write.factory;
+
+import io.fd.hc2vpp.acl.AclIIds;
+import io.fd.hc2vpp.acl.write.AclCustomizer;
+import io.fd.hc2vpp.acl.write.AclValidator;
+import io.fd.honeycomb.translate.impl.write.GenericListWriter;
+import io.fd.honeycomb.translate.write.WriterFactory;
+import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
+import javax.annotation.Nonnull;
+
+public class AclWriterFactory extends AbstractAclWriterFactory implements WriterFactory {
+
+    @Override
+    public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
+
+        registry.subtreeAddBefore(AclIIds.vppAclChildren(AclIIds.ACL),
+                new GenericListWriter<>(AclIIds.ACLS_ACL,
+                        new AclCustomizer(futureAclFacade, standardAclContext, macIpAclContext),
+                        new AclValidator()
+                ),
+                AclIIds.aclHandledChildren(AclIIds.IFC_ACL));
+    }
+}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java
index 12be40a14..c5144b362 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java
@@ -17,46 +17,27 @@
 package io.fd.hc2vpp.acl.write.factory;
 
 import com.google.common.collect.ImmutableSet;
+import io.fd.hc2vpp.acl.AclIIds;
 import io.fd.hc2vpp.acl.write.InterfaceAclCustomizer;
-import io.fd.hc2vpp.acl.write.InterfaceAclMacIpCustomizer;
 import io.fd.honeycomb.translate.impl.write.GenericWriter;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
 import java.util.Set;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public class InterfaceAclWriterFactory extends AbstractAclWriterFactory implements WriterFactory {
 
-    static final InstanceIdentifier<Acl> ACL_IID =
-        InstanceIdentifier.create(Interfaces.class).child(Interface.class)
-            .augmentation(VppAclInterfaceAugmentation.class).child(Acl.class);
-    private static final InstanceIdentifier<Interface> IFC_ID =
-        InstanceIdentifier.create(Interfaces.class).child(Interface.class);
-
-
     @Override
     public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
-        registry.subtreeAddAfter(aclHandledChildren(InstanceIdentifier.create(Acl.class)),
-            new GenericWriter<>(ACL_IID,
-                new InterfaceAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID);
-
-        registry.addAfter(new GenericWriter<>(ACL_IID.child(Ingress.class).child(VppMacipAcl.class),
-            new InterfaceAclMacIpCustomizer(futureAclFacade, macIpAClContext, interfaceContext)), IFC_ID);
+        registry.subtreeAddAfter(AclIIds.aclHandledChildren(AclIIds.IFC_ACL),
+                new GenericWriter<>(AclIIds.ACLS_AP_INT,
+                        new InterfaceAclCustomizer(futureAclFacade, interfaceContext, standardAclContext,
+                                macIpAclContext)),
+                aclRequiredIids());
     }
 
-    static Set<InstanceIdentifier<?>> aclHandledChildren(final InstanceIdentifier<Acl> parentId) {
-        return ImmutableSet.of(parentId.child(Ingress.class),
-            parentId.child(Ingress.class).child(VppAcls.class),
-            parentId.child(Egress.class),
-            parentId.child(Egress.class).child(VppAcls.class));
+    static Set<InstanceIdentifier<?>> aclRequiredIids() {
+        return ImmutableSet.of(AclIIds.IFC, AclIIds.IFC_ACL, AclIIds.ACLS_ACL);
     }
 }
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java
deleted file mode 100644
index 883cf4f1f..000000000
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * 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 io.fd.hc2vpp.acl.write.factory;
-
-import static io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory.ACL_IID;
-import static io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory.aclHandledChildren;
-
-import io.fd.hc2vpp.acl.util.factory.AclFactory;
-import io.fd.hc2vpp.acl.write.VppAclCustomizer;
-import io.fd.hc2vpp.acl.write.VppAclValidator;
-import io.fd.honeycomb.translate.impl.write.GenericListWriter;
-import io.fd.honeycomb.translate.write.WriterFactory;
-import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessLists;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class VppAclWriterFactory extends AbstractAclWriterFactory implements WriterFactory, AclFactory {
-
-    @Override
-    public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
-        final InstanceIdentifier<AccessLists> rootNode = InstanceIdentifier.create(AccessLists.class);
-
-        registry.subtreeAddBefore(vppAclChildren(InstanceIdentifier.create(Acl.class)),
-            new GenericListWriter<>(rootNode.child(Acl.class),
-                new VppAclCustomizer(futureAclFacade, standardAclContext, macIpAClContext),
-                new VppAclValidator()
-            ),
-            aclHandledChildren(ACL_IID));
-    }
-}
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclWriter.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclAddReplaceRequest.java
index 32e20ebac..29a7c7489 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclWriter.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclAddReplaceRequest.java
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-package io.fd.hc2vpp.acl.util.acl;
+package io.fd.hc2vpp.acl.write.request;
 
 import io.fd.hc2vpp.acl.util.AclContextManager;
 import io.fd.hc2vpp.acl.util.ace.AceConverter;
+import io.fd.hc2vpp.acl.util.acl.AclDataExtractor;
 import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.MappingContext;
 import io.fd.honeycomb.translate.write.WriteFailedException;
@@ -30,21 +31,25 @@ import io.fd.vpp.jvpp.acl.dto.MacipAclDel;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import java.util.List;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
-/**
- * Write standard and mac-ip acls
- */
-public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyConsumer {
+public class AclAddReplaceRequest implements AclDataExtractor, AceConverter, JvppReplyConsumer {
 
     int ACL_INDEX_CREATE_NEW = -1;
+    private final FutureJVppAclFacade futureFacade;
+    private final MappingContext mappingContext;
+
+    public AclAddReplaceRequest(@Nonnull final FutureJVppAclFacade futureFacade,
+                                @Nonnull final MappingContext mappingContext) {
+        this.futureFacade = futureFacade;
+        this.mappingContext = mappingContext;
+    }
 
-    default void addStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade,
-                                @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
-                                @Nonnull final AclContextManager standardAclContext,
-                                @Nonnull final MappingContext mappingContext) throws WriteFailedException {
+
+    public void addStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
+                               @Nonnull final AclContextManager standardAclContext) throws WriteFailedException {
 
         final AclAddReplace request = new AclAddReplace();
 
@@ -59,38 +64,35 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons
                 getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id);
 
         // maps new acl to returned index
-        standardAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext);
+        standardAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext);
     }
 
     // according to vpp team, this was tested extensively, and should work
-    default void updateStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade,
-                                   @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
-                                   @Nonnull final AclContextManager standardAclContext,
-                                   @Nonnull final MappingContext mappingContext) throws WriteFailedException {
+    public void updateStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
+                                  @Nonnull final AclContextManager standardAclContext) throws WriteFailedException {
 
         final AclAddReplace request = new AclAddReplace();
 
         request.tag = getAclTag(acl);
         // by setting existing index, request is resolved as update
-        request.aclIndex = standardAclContext.getAclIndex(acl.getAclName(), mappingContext);
+        request.aclIndex = standardAclContext.getAclIndex(acl.getName(), mappingContext);
 
         final List<Ace> aces = getAces(acl);
         request.r = toStandardAclRules(aces);
         request.count = request.r.length;
 
-        final AclAddReplaceReply reply = getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id);
+        final AclAddReplaceReply reply =
+                getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id);
 
         // overwrites existing acl metadata (aces might have been changed):
-        standardAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext);
+        standardAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext);
     }
 
-    default void deleteStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade,
-                                   @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
-                                   @Nonnull final AclContextManager standardAclContext,
-                                   @Nonnull final MappingContext mappingContext) throws WriteFailedException {
+    public void deleteStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
+                                  @Nonnull final AclContextManager standardAclContext) throws WriteFailedException {
 
         final AclDel request = new AclDel();
-        final String aclName = acl.getAclName();
+        final String aclName = acl.getName();
         request.aclIndex = standardAclContext.getAclIndex(aclName, mappingContext);
 
         getReplyForDelete(futureFacade.aclDel(request).toCompletableFuture(), id);
@@ -99,10 +101,8 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons
         standardAclContext.removeAcl(aclName, mappingContext);
     }
 
-    default void addMacIpAcl(@Nonnull final FutureJVppAclFacade futureFacade,
-                             @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
-                             @Nonnull final AclContextManager macIpAclContext,
-                             @Nonnull final MappingContext mappingContext) throws WriteFailedException {
+    public void addMacIpAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
+                            @Nonnull final AclContextManager macIpAclContext) throws WriteFailedException {
         final MacipAclAdd request = new MacipAclAdd();
 
         request.tag = getAclTag(acl);
@@ -114,15 +114,13 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons
         final MacipAclAddReply reply = getReplyForWrite(futureFacade.macipAclAdd(request).toCompletableFuture(), id);
 
         // map mac-ip acl to returned index
-        macIpAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext);
+        macIpAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext);
     }
 
-    default void deleteMacIpAcl(@Nonnull final FutureJVppAclFacade futureFacade,
-                                @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
-                                @Nonnull final AclContextManager macIpAclContext,
-                                @Nonnull final MappingContext mappingContext) throws WriteFailedException {
+    public void deleteMacIpAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl,
+                               @Nonnull final AclContextManager macIpAclContext) throws WriteFailedException {
         final MacipAclDel request = new MacipAclDel();
-        final String aclName = acl.getAclName();
+        final String aclName = acl.getName();
         request.aclIndex = macIpAclContext.getAclIndex(aclName, mappingContext);
 
         getReplyForDelete(futureFacade.macipAclDel(request).toCompletableFuture(), id);
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequest.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclInterfaceAssignmentRequest.java
index bf1f1497e..2d7777e35 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequest.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclInterfaceAssignmentRequest.java
@@ -15,7 +15,7 @@
  */
 
 
-package io.fd.hc2vpp.acl.util.iface.acl;
+package io.fd.hc2vpp.acl.write.request;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -32,8 +32,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Stream;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -46,7 +45,8 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat
     private static final Logger LOG = LoggerFactory.getLogger(AclInterfaceAssignmentRequest.class);
 
     private final MappingContext mappingContext;
-    private InstanceIdentifier<Acl> identifier;
+    private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface>
+            identifier;
     private List<String> inputAclNames = Collections.emptyList();
     private List<String> outputAclNames = Collections.emptyList();
     private AclContextManager standardAclContext;
@@ -62,7 +62,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat
     }
 
     public AclInterfaceAssignmentRequest identifier(
-            @Nonnull final InstanceIdentifier<Acl> identifier) {
+            @Nonnull final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> identifier) {
         this.identifier = identifier;
         return this;
     }
@@ -97,7 +97,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat
 
     public void executeAsCreate(@Nonnull final FutureJVppAclFacade api) throws WriteFailedException {
         checkValidRequest();
-        final String interfaceName = identifier.firstKeyOf(Interface.class).getName();
+        final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId();
 
         // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request
         synchronized (mappingContext) {
@@ -113,10 +113,12 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat
         }
     }
 
-    public void executeAsUpdate(@Nonnull final FutureJVppAclFacade api, final Acl before, final Acl after)
+    public void executeAsUpdate(@Nonnull final FutureJVppAclFacade api,
+                                final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface before,
+                                final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface after)
             throws WriteFailedException {
         checkValidRequest();
-        final String interfaceName = identifier.firstKeyOf(Interface.class).getName();
+        final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId();
 
         // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request
         synchronized (mappingContext) {
@@ -134,7 +136,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat
 
     public void executeAsDelete(@Nonnull final FutureJVppAclFacade api) throws WriteFailedException {
         checkValidRequest();
-        final String interfaceName = identifier.firstKeyOf(Interface.class).getName();
+        final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId();
 
         // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request
         synchronized (mappingContext) {
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequest.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/MacIpInterfaceAssignmentRequest.java
index 882cfd631..b7849991b 100644
--- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequest.java
+++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/MacIpInterfaceAssignmentRequest.java
@@ -15,7 +15,7 @@
  */
 
 
-package io.fd.hc2vpp.acl.util.iface.macip;
+package io.fd.hc2vpp.acl.write.request;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -28,8 +28,7 @@ import io.fd.honeycomb.translate.write.WriteFailedException;
 import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDel;
 import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -40,7 +39,8 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp
 
     private final boolean isNew;
     private final MappingContext mappingContext;
-    private InstanceIdentifier<VppMacipAcl> identifier;
+    private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface>
+            identifier;
     private String aclName;
     private AclContextManager macIpAclContext;
     private NamingContext interfaceContext;
@@ -59,7 +59,8 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp
         return new MacIpInterfaceAssignmentRequest(false, mappingContext);
     }
 
-    public MacIpInterfaceAssignmentRequest identifier(@Nonnull final InstanceIdentifier<VppMacipAcl> identifier) {
+    public MacIpInterfaceAssignmentRequest identifier(
+            @Nonnull final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> identifier) {
         this.identifier = identifier;
         return this;
     }
@@ -93,7 +94,7 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp
         synchronized (mappingContext) {
             checkValidRequest();
 
-            final String interfaceName = identifier.firstKeyOf(Interface.class).getName();
+            final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId();
 
             MacipAclInterfaceAddDel request = new MacipAclInterfaceAddDel();
             request.isAdd = booleanToByte(isNew);