HONEYCOMB-236 - Unified read/write exceptions

Change-Id: Idde761d0c0c2c4d96555ef94dbdaa87fad889493
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>

14 files changed, 434 insertions, 519 deletions

diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/GreCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/GreCustomizer.java
index d142a8e55..58e0d8bb7 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/GreCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/GreCustomizer.java
@@ -23,6 +23,10 @@ import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.GreTunnelDetails;
+import io.fd.vpp.jvpp.core.dto.GreTunnelDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.GreTunnelDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Arrays;
@@ -40,11 +44,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.GreTunnelDetails;
-import io.fd.vpp.jvpp.core.dto.GreTunnelDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.GreTunnelDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -75,60 +74,55 @@ public class GreCustomizer extends FutureJVppCustomizer
     public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id,
                                       @Nonnull final GreBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
-        try {
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
-            if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, GreTunnel.class, LOG)) {
-                return;
-            }
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
+        if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, GreTunnel.class, LOG)) {
+            return;
+        }
 
-            LOG.debug("Reading attributes for gre tunnel: {}", key.getName());
-            // Dump just a single
-            final GreTunnelDump request = new GreTunnelDump();
-            request.swIfIndex = index;
+        LOG.debug("Reading attributes for gre tunnel: {}", key.getName());
+        // Dump just a single
+        final GreTunnelDump request = new GreTunnelDump();
+        request.swIfIndex = index;
 
-            final CompletionStage<GreTunnelDetailsReplyDump> swInterfaceGreDetailsReplyDumpCompletionStage =
-                    getFutureJVpp().greTunnelDump(request);
-            final GreTunnelDetailsReplyDump reply =
-                    getReplyForRead(swInterfaceGreDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
+        final CompletionStage<GreTunnelDetailsReplyDump> swInterfaceGreDetailsReplyDumpCompletionStage =
+                getFutureJVpp().greTunnelDump(request);
+        final GreTunnelDetailsReplyDump reply =
+                getReplyForRead(swInterfaceGreDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
 
-            // VPP keeps gre tunnel interfaces even after they were deleted (optimization)
-            // However there ar no longer any gre tunnel specific fields assigned to it and this call
-            // returns nothing
-            if (reply == null || reply.greTunnelDetails == null || reply.greTunnelDetails.isEmpty()) {
-                LOG.debug(
-                        "Gre tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
-                                "after delete", key.getName(), index);
-                return;
-            }
+        // VPP keeps gre tunnel interfaces even after they were deleted (optimization)
+        // However there ar no longer any gre tunnel specific fields assigned to it and this call
+        // returns nothing
+        if (reply == null || reply.greTunnelDetails == null || reply.greTunnelDetails.isEmpty()) {
+            LOG.debug(
+                    "Gre tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
+                            "after delete", key.getName(), index);
+            return;
+        }
 
-            checkState(reply.greTunnelDetails.size() == 1,
-                    "Unexpected number of returned gre tunnels: {} for tunnel: {}", reply.greTunnelDetails,
-                    key.getName());
-            LOG.trace("Gre tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
+        checkState(reply.greTunnelDetails.size() == 1,
+                "Unexpected number of returned gre tunnels: {} for tunnel: {}", reply.greTunnelDetails,
+                key.getName());
+        LOG.trace("Gre tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
 
-            final GreTunnelDetails swInterfaceGreDetails = reply.greTunnelDetails.get(0);
-            if (swInterfaceGreDetails.isIpv6 == 1) {
-                final Ipv6Address dstIpv6 =
-                        new Ipv6Address(parseAddress(swInterfaceGreDetails.dstAddress).getHostAddress());
-                builder.setDst(new IpAddress(dstIpv6));
-                final Ipv6Address srcIpv6 =
-                        new Ipv6Address(parseAddress(swInterfaceGreDetails.srcAddress).getHostAddress());
-                builder.setSrc(new IpAddress(srcIpv6));
-            } else {
-                final byte[] dstBytes = Arrays.copyOfRange(swInterfaceGreDetails.dstAddress, 0, 4);
-                final Ipv4Address dstIpv4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
-                builder.setDst(new IpAddress(dstIpv4));
-                final byte[] srcBytes = Arrays.copyOfRange(swInterfaceGreDetails.srcAddress, 0, 4);
-                final Ipv4Address srcIpv4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
-                builder.setSrc(new IpAddress(srcIpv4));
-            }
-            builder.setOuterFibId((long) swInterfaceGreDetails.outerFibId);
-            LOG.debug("Gre tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
-        } catch (VppBaseCallException e) {
-            LOG.warn("Failed to readCurrentAttributes for: {}", id, e);
-            throw new ReadFailedException(id, e);
+        final GreTunnelDetails swInterfaceGreDetails = reply.greTunnelDetails.get(0);
+        if (swInterfaceGreDetails.isIpv6 == 1) {
+            final Ipv6Address dstIpv6 =
+                    new Ipv6Address(parseAddress(swInterfaceGreDetails.dstAddress).getHostAddress());
+            builder.setDst(new IpAddress(dstIpv6));
+            final Ipv6Address srcIpv6 =
+                    new Ipv6Address(parseAddress(swInterfaceGreDetails.srcAddress).getHostAddress());
+            builder.setSrc(new IpAddress(srcIpv6));
+        } else {
+            final byte[] dstBytes = Arrays.copyOfRange(swInterfaceGreDetails.dstAddress, 0, 4);
+            final Ipv4Address dstIpv4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
+            builder.setDst(new IpAddress(dstIpv4));
+            final byte[] srcBytes = Arrays.copyOfRange(swInterfaceGreDetails.srcAddress, 0, 4);
+            final Ipv4Address srcIpv4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
+            builder.setSrc(new IpAddress(srcIpv4));
         }
+        builder.setOuterFibId((long) swInterfaceGreDetails.outerFibId);
+        LOG.debug("Gre tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
     }
 
     @Nonnull
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterconnectionReadUtils.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterconnectionReadUtils.java
index 2177c7460..c8e07a82f 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterconnectionReadUtils.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterconnectionReadUtils.java
@@ -22,6 +22,12 @@ import static java.util.Objects.requireNonNull;
 import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.BridgeDomainDetails;
+import io.fd.vpp.jvpp.core.dto.BridgeDomainDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.BridgeDomainDump;
+import io.fd.vpp.jvpp.core.dto.BridgeDomainSwIfDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import javax.annotation.Nonnull;
@@ -29,13 +35,6 @@ import javax.annotation.Nullable;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.Interconnection;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.interconnection.BridgeBasedBuilder;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.BridgeDomainDetails;
-import io.fd.vpp.jvpp.core.dto.BridgeDomainDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.BridgeDomainDump;
-import io.fd.vpp.jvpp.core.dto.BridgeDomainSwIfDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -112,18 +111,15 @@ final class InterconnectionReadUtils implements InterfaceDataTranslator {
 
     private BridgeDomainDetailsReplyDump getDumpReply(@Nonnull final InstanceIdentifier<?> id)
             throws ReadFailedException {
-        try {
-            // We need to perform full bd dump, because there is no way
-            // to ask VPP for BD details given interface id/name (TODO HONEYCOMB-190 add it to vpp.api?)
-            // TODO HONEYCOMB-190 cache dump result
-            final BridgeDomainDump request = new BridgeDomainDump();
-            request.bdId = -1;
-
-            final CompletableFuture<BridgeDomainDetailsReplyDump> bdCompletableFuture =
-                    futureJVppCore.bridgeDomainSwIfDump(request).toCompletableFuture();
-            return getReplyForRead(bdCompletableFuture, id);
-        } catch (VppBaseCallException e) {
-            throw new ReadFailedException(id, e);
-        }
+        // We need to perform full bd dump, because there is no way
+        // to ask VPP for BD details given interface id/name (TODO HONEYCOMB-190 add it to vpp.api?)
+        // TODO HONEYCOMB-190 cache dump result
+        final BridgeDomainDump request = new BridgeDomainDump();
+        request.bdId = -1;
+
+        final CompletableFuture<BridgeDomainDetailsReplyDump> bdCompletableFuture =
+                futureJVppCore.bridgeDomainSwIfDump(request).toCompletableFuture();
+        return getReplyForRead(bdCompletableFuture, id);
+
     }
 }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java
index 7fcb995db..3093f08a7 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java
@@ -25,6 +25,10 @@ import io.fd.honeycomb.translate.v3po.DisabledInterfacesManager;
 import io.fd.honeycomb.translate.vpp.util.ByteDataTranslator;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -42,11 +46,6 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -136,71 +135,66 @@ public class InterfaceCustomizer extends FutureJVppCustomizer
     @Override
     public List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> id,
                                         @Nonnull final ReadContext context) throws ReadFailedException {
-        try {
-            final List<InterfaceKey> interfacesKeys;
-            LOG.trace("Dumping all interfaces to get all IDs");
-
-            final SwInterfaceDump request = new SwInterfaceDump();
-            request.nameFilter = "".getBytes();
-            request.nameFilterValid = 0;
-
-            final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
-                    getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
-            final SwInterfaceDetailsReplyDump ifaces =
-                    getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
-
-            if (null == ifaces || null == ifaces.swInterfaceDetails) {
-                LOG.debug("No interfaces for :{} found in VPP", id);
-                return Collections.emptyList();
-            }
-
-            // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
-            context.getModificationCache().put(DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream()
-                    .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails)));
-
-            final MappingContext mappingCtx = context.getMappingContext();
-            final Set<Integer> interfacesIdxs = ifaces.swInterfaceDetails.stream()
-                    .filter(elt -> elt != null)
-                    // Filter out disabled interfaces, dont read them
-                    // This also prevents child readers in being invoked such as vxlan (which relies on disabling interfaces)
-                    .filter(elt -> !interfaceDisableContext
-                            .isInterfaceDisabled(elt.swIfIndex, mappingCtx))
-                    .map((elt) -> {
-                        // Store interface name from VPP in context if not yet present
-                        if (!interfaceNamingContext.containsName(elt.swIfIndex, mappingCtx)) {
-                            interfaceNamingContext.addName(elt.swIfIndex, toString(elt.interfaceName),
-                                    mappingCtx);
-                        }
-                        LOG.trace("Interface with name: {}, VPP name: {} and index: {} found in VPP",
-                                interfaceNamingContext.getName(elt.swIfIndex, mappingCtx),
-                                elt.interfaceName,
-                                elt.swIfIndex);
-
-                        return elt;
-                    })
-                    // filter out sub-interfaces
-                    .filter(InterfaceCustomizer::isRegularInterface)
-                    .map(elt -> elt.swIfIndex)
-                    .collect(Collectors.toSet());
-
-            // Clean disabled interfaces list
-            interfaceDisableContext.getDisabledInterfaces(mappingCtx).stream()
-                    // Find indices not currently in VPP
-                    .filter(interfacesIdxs::contains)
-                    // Remove from disabled list ... not disabled if not existing
-                    .forEach(idx -> interfaceDisableContext.removeDisabledInterface(idx, mappingCtx));
-
-            // Transform indices to keys
-            interfacesKeys = interfacesIdxs.stream()
-                    .map(index -> new InterfaceKey(interfaceNamingContext.getName(index, context.getMappingContext())))
-                    .collect(Collectors.toList());
-
-            LOG.debug("Interfaces found in VPP: {}", interfacesKeys);
-            return interfacesKeys;
-        } catch (VppBaseCallException e) {
-            LOG.warn("getAllIds for id :{} failed with exception ", id, e);
-            throw new ReadFailedException(id, e);
+        final List<InterfaceKey> interfacesKeys;
+        LOG.trace("Dumping all interfaces to get all IDs");
+
+        final SwInterfaceDump request = new SwInterfaceDump();
+        request.nameFilter = "".getBytes();
+        request.nameFilterValid = 0;
+
+        final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
+                getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
+        final SwInterfaceDetailsReplyDump ifaces =
+                getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
+
+        if (null == ifaces || null == ifaces.swInterfaceDetails) {
+            LOG.debug("No interfaces for :{} found in VPP", id);
+            return Collections.emptyList();
         }
+
+        // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
+        context.getModificationCache().put(DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream()
+                .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails)));
+
+        final MappingContext mappingCtx = context.getMappingContext();
+        final Set<Integer> interfacesIdxs = ifaces.swInterfaceDetails.stream()
+                .filter(elt -> elt != null)
+                // Filter out disabled interfaces, dont read them
+                // This also prevents child readers in being invoked such as vxlan (which relies on disabling interfaces)
+                .filter(elt -> !interfaceDisableContext
+                        .isInterfaceDisabled(elt.swIfIndex, mappingCtx))
+                .map((elt) -> {
+                    // Store interface name from VPP in context if not yet present
+                    if (!interfaceNamingContext.containsName(elt.swIfIndex, mappingCtx)) {
+                        interfaceNamingContext.addName(elt.swIfIndex, toString(elt.interfaceName),
+                                mappingCtx);
+                    }
+                    LOG.trace("Interface with name: {}, VPP name: {} and index: {} found in VPP",
+                            interfaceNamingContext.getName(elt.swIfIndex, mappingCtx),
+                            elt.interfaceName,
+                            elt.swIfIndex);
+
+                    return elt;
+                })
+                // filter out sub-interfaces
+                .filter(InterfaceCustomizer::isRegularInterface)
+                .map(elt -> elt.swIfIndex)
+                .collect(Collectors.toSet());
+
+        // Clean disabled interfaces list
+        interfaceDisableContext.getDisabledInterfaces(mappingCtx).stream()
+                // Find indices not currently in VPP
+                .filter(interfacesIdxs::contains)
+                // Remove from disabled list ... not disabled if not existing
+                .forEach(idx -> interfaceDisableContext.removeDisabledInterface(idx, mappingCtx));
+
+        // Transform indices to keys
+        interfacesKeys = interfacesIdxs.stream()
+                .map(index -> new InterfaceKey(interfaceNamingContext.getName(index, context.getMappingContext())))
+                .collect(Collectors.toList());
+
+        LOG.debug("Interfaces found in VPP: {}", interfacesKeys);
+        return interfacesKeys;
     }
 
     @Override
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java
index 81012e21e..2cc8ce250 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java
@@ -24,6 +24,10 @@ import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.util.RWUtils;
 import io.fd.honeycomb.translate.vpp.util.ByteDataTranslator;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.math.BigInteger;
 import java.util.Map;
 import java.util.Objects;
@@ -41,11 +45,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanGpeTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanTunnel;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 
 public interface InterfaceDataTranslator extends ByteDataTranslator, JvppReplyConsumer {
@@ -195,32 +194,28 @@ public interface InterfaceDataTranslator extends ByteDataTranslator, JvppReplyCo
         }
 
         SwInterfaceDetailsReplyDump ifaces;
-        try {
-            CompletionStage<SwInterfaceDetailsReplyDump> requestFuture = futureJVppCore.swInterfaceDump(request);
-            ifaces = getReplyForRead(requestFuture.toCompletableFuture(), id);
-            if (null == ifaces || null == ifaces.swInterfaceDetails || ifaces.swInterfaceDetails.isEmpty()) {
-                request.nameFilterValid = 0;
 
-                callerLogger.warn("VPP returned null instead of interface by key {} and its not cached", name);
-                callerLogger.warn("Iterating through all the interfaces to find interface: {}", name);
+        CompletionStage<SwInterfaceDetailsReplyDump> requestFuture = futureJVppCore.swInterfaceDump(request);
+        ifaces = getReplyForRead(requestFuture.toCompletableFuture(), id);
+        if (null == ifaces || null == ifaces.swInterfaceDetails || ifaces.swInterfaceDetails.isEmpty()) {
+            request.nameFilterValid = 0;
 
-                // Or else just perform full dump and do inefficient filtering
-                requestFuture = futureJVppCore.swInterfaceDump(request);
-                ifaces = getReplyForRead(requestFuture.toCompletableFuture(), id);
+            callerLogger.warn("VPP returned null instead of interface by key {} and its not cached", name);
+            callerLogger.warn("Iterating through all the interfaces to find interface: {}", name);
+
+            // Or else just perform full dump and do inefficient filtering
+            requestFuture = futureJVppCore.swInterfaceDump(request);
+            ifaces = getReplyForRead(requestFuture.toCompletableFuture(), id);
 
-                // Update the cache
-                allInterfaces.clear();
-                allInterfaces
-                        .putAll(ifaces.swInterfaceDetails.stream().collect(Collectors.toMap(d -> d.swIfIndex, d -> d)));
+            // Update the cache
+            allInterfaces.clear();
+            allInterfaces
+                    .putAll(ifaces.swInterfaceDetails.stream().collect(Collectors.toMap(d -> d.swIfIndex, d -> d)));
 
-                if (allInterfaces.containsKey(index)) {
-                    return allInterfaces.get(index);
-                }
-                throw new IllegalArgumentException("Unable to find interface " + name);
+            if (allInterfaces.containsKey(index)) {
+                return allInterfaces.get(index);
             }
-        } catch (VppBaseCallException e) {
-            callerLogger.warn("getVppInterfaceDetails for id :{} and name :{} failed with exception :", id, name, e);
-            throw new ReadFailedException(id, e);
+            throw new IllegalArgumentException("Unable to find interface " + name);
         }
 
         // SwInterfaceDump's name filter does prefix match, so we need additional filtering:
@@ -263,8 +258,8 @@ public interface InterfaceDataTranslator extends ByteDataTranslator, JvppReplyCo
 
     /**
      * Check interface type. Uses interface details from VPP to determine. Uses {@link
-     * #getVppInterfaceDetails(FutureJVppCore, InstanceIdentifier, String, int, ModificationCache, Logger)} internally so
-     * tries to utilize cache before asking VPP.
+     * #getVppInterfaceDetails(FutureJVppCore, InstanceIdentifier, String, int, ModificationCache, Logger)} internally
+     * so tries to utilize cache before asking VPP.
      */
     default boolean isInterfaceOfType(@Nonnull final FutureJVppCore jvpp,
                                       @Nonnull final ModificationCache cache,
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/SubInterfaceCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/SubInterfaceCustomizer.java
index e618f81e3..a253d0828 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/SubInterfaceCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/SubInterfaceCustomizer.java
@@ -26,6 +26,10 @@ import io.fd.honeycomb.translate.vpp.util.ByteDataTranslator;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
 import io.fd.honeycomb.translate.vpp.util.SubInterfaceUtils;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -59,11 +63,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -110,47 +109,43 @@ public class SubInterfaceCustomizer extends FutureJVppCustomizer
     @Override
     public List<SubInterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<SubInterface> id,
                                            @Nonnull final ReadContext context) throws ReadFailedException {
-        try {
-            // Relying here that parent InterfaceCustomizer was invoked first (PREORDER)
-            // to fill in the context with initial ifc mapping
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final String ifaceName = key.getName();
-            final int ifaceId = interfaceContext.getIndex(ifaceName, context.getMappingContext());
-
-            // TODO HONEYCOMB-189 if we know that full dump was already performed we could use cache
-            // (checking if getCachedInterfaceDump() returns non empty map is not enough, because
-            // we could be part of particular iface state read
-            final SwInterfaceDump request = new SwInterfaceDump();
-            request.nameFilter = "".getBytes();
-            request.nameFilterValid = 0;
-
-            final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
-                    getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
-            final SwInterfaceDetailsReplyDump ifaces =
-                    getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
-
-            if (null == ifaces || null == ifaces.swInterfaceDetails) {
-                LOG.warn("Looking for sub-interfaces, but no interfaces found in VPP");
-                return Collections.emptyList();
-            }
-
-            // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
-            context.getModificationCache()
-                    .put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream()
-                            .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails)));
-
-            final List<SubInterfaceKey> interfacesKeys = ifaces.swInterfaceDetails.stream()
-                    .filter(elt -> elt != null)
-                    // accept only sub-interfaces for current iface:
-                    .filter(elt -> elt.subId != 0 && elt.supSwIfIndex == ifaceId)
-                    .map(details -> new SubInterfaceKey(new Long(details.subId)))
-                    .collect(Collectors.toList());
-
-            LOG.debug("Sub-interfaces of {} found in VPP: {}", ifaceName, interfacesKeys);
-            return interfacesKeys;
-        } catch (VppBaseCallException e) {
-            throw new ReadFailedException(id, e);
+        // Relying here that parent InterfaceCustomizer was invoked first (PREORDER)
+        // to fill in the context with initial ifc mapping
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final String ifaceName = key.getName();
+        final int ifaceId = interfaceContext.getIndex(ifaceName, context.getMappingContext());
+
+        // TODO HONEYCOMB-189 if we know that full dump was already performed we could use cache
+        // (checking if getCachedInterfaceDump() returns non empty map is not enough, because
+        // we could be part of particular iface state read
+        final SwInterfaceDump request = new SwInterfaceDump();
+        request.nameFilter = "".getBytes();
+        request.nameFilterValid = 0;
+
+        final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
+                getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
+        final SwInterfaceDetailsReplyDump ifaces =
+                getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
+
+        if (null == ifaces || null == ifaces.swInterfaceDetails) {
+            LOG.warn("Looking for sub-interfaces, but no interfaces found in VPP");
+            return Collections.emptyList();
         }
+
+        // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
+        context.getModificationCache()
+                .put(InterfaceCustomizer.DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream()
+                        .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails)));
+
+        final List<SubInterfaceKey> interfacesKeys = ifaces.swInterfaceDetails.stream()
+                .filter(elt -> elt != null)
+                // accept only sub-interfaces for current iface:
+                .filter(elt -> elt.subId != 0 && elt.supSwIfIndex == ifaceId)
+                .map(details -> new SubInterfaceKey(new Long(details.subId)))
+                .collect(Collectors.toList());
+
+        LOG.debug("Sub-interfaces of {} found in VPP: {}", ifaceName, interfacesKeys);
+        return interfacesKeys;
     }
 
     @Override
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/TapCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/TapCustomizer.java
index c61777423..e2cea64cd 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/TapCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/TapCustomizer.java
@@ -22,6 +22,10 @@ import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -36,11 +40,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceTapDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -72,48 +71,44 @@ public class TapCustomizer extends FutureJVppCustomizer
     public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Tap> id,
                                       @Nonnull final TapBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
-        try {
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
-            if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index,
-                    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.Tap.class, LOG)) {
-                return;
-            }
 
-            LOG.debug("Reading attributes for tap interface: {}", key.getName());
-
-            @SuppressWarnings("unchecked")
-            Map<Integer, SwInterfaceTapDetails> mappedTaps =
-                    (Map<Integer, SwInterfaceTapDetails>) ctx.getModificationCache().get(DUMPED_TAPS_CONTEXT_KEY);
-
-            if (mappedTaps == null) {
-                // Full Tap dump has to be performed here, no filter or anything is here to help so at least we cache it
-                final SwInterfaceTapDump request = new SwInterfaceTapDump();
-                final CompletionStage<SwInterfaceTapDetailsReplyDump> swInterfaceTapDetailsReplyDumpCompletionStage =
-                        getFutureJVpp().swInterfaceTapDump(request);
-                final SwInterfaceTapDetailsReplyDump reply =
-                        getReplyForRead(swInterfaceTapDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
-
-                if (null == reply || null == reply.swInterfaceTapDetails) {
-                    mappedTaps = Collections.emptyMap();
-                } else {
-                    final List<SwInterfaceTapDetails> swInterfaceTapDetails = reply.swInterfaceTapDetails;
-                    // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
-                    mappedTaps = swInterfaceTapDetails.stream()
-                            .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails));
-                }
-
-                ctx.getModificationCache().put(DUMPED_TAPS_CONTEXT_KEY, mappedTaps);
-            }
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
+        if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index,
+                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.Tap.class, LOG)) {
+            return;
+        }
 
-            final SwInterfaceTapDetails swInterfaceTapDetails = mappedTaps.get(index);
-            LOG.trace("Tap interface: {} attributes returned from VPP: {}", key.getName(), swInterfaceTapDetails);
+        LOG.debug("Reading attributes for tap interface: {}", key.getName());
+
+        @SuppressWarnings("unchecked")
+        Map<Integer, SwInterfaceTapDetails> mappedTaps =
+                (Map<Integer, SwInterfaceTapDetails>) ctx.getModificationCache().get(DUMPED_TAPS_CONTEXT_KEY);
+
+        if (mappedTaps == null) {
+            // Full Tap dump has to be performed here, no filter or anything is here to help so at least we cache it
+            final SwInterfaceTapDump request = new SwInterfaceTapDump();
+            final CompletionStage<SwInterfaceTapDetailsReplyDump> swInterfaceTapDetailsReplyDumpCompletionStage =
+                    getFutureJVpp().swInterfaceTapDump(request);
+            final SwInterfaceTapDetailsReplyDump reply =
+                    getReplyForRead(swInterfaceTapDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
+
+            if (null == reply || null == reply.swInterfaceTapDetails) {
+                mappedTaps = Collections.emptyMap();
+            } else {
+                final List<SwInterfaceTapDetails> swInterfaceTapDetails = reply.swInterfaceTapDetails;
+                // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
+                mappedTaps = swInterfaceTapDetails.stream()
+                        .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails));
+            }
 
-            builder.setTapName(toString(swInterfaceTapDetails.devName));
-            LOG.debug("Tap interface: {}, id: {} attributes read as: {}", key.getName(), index, builder);
-        } catch (VppBaseCallException e) {
-            LOG.warn("Failed to readCurrentAttributes for: {}", id, e);
-            throw new ReadFailedException(id, e);
+            ctx.getModificationCache().put(DUMPED_TAPS_CONTEXT_KEY, mappedTaps);
         }
+
+        final SwInterfaceTapDetails swInterfaceTapDetails = mappedTaps.get(index);
+        LOG.trace("Tap interface: {} attributes returned from VPP: {}", key.getName(), swInterfaceTapDetails);
+
+        builder.setTapName(toString(swInterfaceTapDetails.devName));
+        LOG.debug("Tap interface: {}, id: {} attributes read as: {}", key.getName(), index, builder);
     }
 }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VhostUserCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VhostUserCustomizer.java
index 0781a3f77..7d575a9b0 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VhostUserCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VhostUserCustomizer.java
@@ -22,6 +22,10 @@ import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDetails;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.math.BigInteger;
 import java.util.Collections;
 import java.util.List;
@@ -38,11 +42,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDetails;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.SwInterfaceVhostUserDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -75,63 +74,59 @@ public class VhostUserCustomizer extends FutureJVppCustomizer
     public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id,
                                       @Nonnull final VhostUserBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
-        try {
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
-            if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index,
-                    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser.class,
-                    LOG)) {
-                return;
-            }
 
-            LOG.debug("Reading attributes for vhpost user interface: {}", key.getName());
-
-            @SuppressWarnings("unchecked")
-            Map<Integer, SwInterfaceVhostUserDetails> mappedVhostUsers =
-                    (Map<Integer, SwInterfaceVhostUserDetails>) ctx.getModificationCache()
-                            .get(DUMPED_VHOST_USERS_CONTEXT_KEY);
-
-            if (mappedVhostUsers == null) {
-                // Full VhostUser dump has to be performed here, no filter or anything is here to help so at least we cache it
-                final SwInterfaceVhostUserDump request = new SwInterfaceVhostUserDump();
-                final CompletionStage<SwInterfaceVhostUserDetailsReplyDump>
-                        swInterfaceVhostUserDetailsReplyDumpCompletionStage =
-                        getFutureJVpp().swInterfaceVhostUserDump(request);
-                final SwInterfaceVhostUserDetailsReplyDump reply =
-                        getReplyForRead(swInterfaceVhostUserDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
-
-                if (null == reply || null == reply.swInterfaceVhostUserDetails) {
-                    mappedVhostUsers = Collections.emptyMap();
-                } else {
-                    final List<SwInterfaceVhostUserDetails> swInterfaceVhostUserDetails =
-                            reply.swInterfaceVhostUserDetails;
-                    // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
-                    mappedVhostUsers = swInterfaceVhostUserDetails.stream()
-                            .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails));
-                }
-
-                ctx.getModificationCache().put(DUMPED_VHOST_USERS_CONTEXT_KEY, mappedVhostUsers);
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
+        if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index,
+                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser.class,
+                LOG)) {
+            return;
+        }
+
+        LOG.debug("Reading attributes for vhpost user interface: {}", key.getName());
+
+        @SuppressWarnings("unchecked")
+        Map<Integer, SwInterfaceVhostUserDetails> mappedVhostUsers =
+                (Map<Integer, SwInterfaceVhostUserDetails>) ctx.getModificationCache()
+                        .get(DUMPED_VHOST_USERS_CONTEXT_KEY);
+
+        if (mappedVhostUsers == null) {
+            // Full VhostUser dump has to be performed here, no filter or anything is here to help so at least we cache it
+            final SwInterfaceVhostUserDump request = new SwInterfaceVhostUserDump();
+            final CompletionStage<SwInterfaceVhostUserDetailsReplyDump>
+                    swInterfaceVhostUserDetailsReplyDumpCompletionStage =
+                    getFutureJVpp().swInterfaceVhostUserDump(request);
+            final SwInterfaceVhostUserDetailsReplyDump reply =
+                    getReplyForRead(swInterfaceVhostUserDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
+
+            if (null == reply || null == reply.swInterfaceVhostUserDetails) {
+                mappedVhostUsers = Collections.emptyMap();
+            } else {
+                final List<SwInterfaceVhostUserDetails> swInterfaceVhostUserDetails =
+                        reply.swInterfaceVhostUserDetails;
+                // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes
+                mappedVhostUsers = swInterfaceVhostUserDetails.stream()
+                        .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails));
             }
 
-            // Relying here that parent InterfaceCustomizer was invoked first to fill in the context with initial ifc mapping
-            final SwInterfaceVhostUserDetails swInterfaceVhostUserDetails = mappedVhostUsers.get(index);
-            LOG.trace("Vhost user interface: {} attributes returned from VPP: {}", key.getName(),
-                    swInterfaceVhostUserDetails);
-
-            builder.setRole(swInterfaceVhostUserDetails.isServer == 1
-                    ? VhostUserRole.Server
-                    : VhostUserRole.Client);
-            builder.setFeatures(BigInteger.valueOf(swInterfaceVhostUserDetails.features));
-            builder.setNumMemoryRegions((long) swInterfaceVhostUserDetails.numRegions);
-            builder.setSocket(toString(swInterfaceVhostUserDetails.sockFilename));
-            builder.setVirtioNetHdrSize((long) swInterfaceVhostUserDetails.virtioNetHdrSz);
-            // TODO: map error code to meaningful message after VPP-436 is done
-            builder.setConnectError(Integer.toString(swInterfaceVhostUserDetails.sockErrno));
-
-            LOG.debug("Vhost user interface: {}, id: {} attributes read as: {}", key.getName(), index, builder);
-        } catch (VppBaseCallException e) {
-            LOG.warn("Failed to readCurrentAttributes for: {}", id, e);
-            throw new ReadFailedException(id, e);
+            ctx.getModificationCache().put(DUMPED_VHOST_USERS_CONTEXT_KEY, mappedVhostUsers);
         }
+
+        // Relying here that parent InterfaceCustomizer was invoked first to fill in the context with initial ifc mapping
+        final SwInterfaceVhostUserDetails swInterfaceVhostUserDetails = mappedVhostUsers.get(index);
+        LOG.trace("Vhost user interface: {} attributes returned from VPP: {}", key.getName(),
+                swInterfaceVhostUserDetails);
+
+        builder.setRole(swInterfaceVhostUserDetails.isServer == 1
+                ? VhostUserRole.Server
+                : VhostUserRole.Client);
+        builder.setFeatures(BigInteger.valueOf(swInterfaceVhostUserDetails.features));
+        builder.setNumMemoryRegions((long) swInterfaceVhostUserDetails.numRegions);
+        builder.setSocket(toString(swInterfaceVhostUserDetails.sockFilename));
+        builder.setVirtioNetHdrSize((long) swInterfaceVhostUserDetails.virtioNetHdrSz);
+        // TODO: map error code to meaningful message after VPP-436 is done
+        builder.setConnectError(Integer.toString(swInterfaceVhostUserDetails.sockErrno));
+
+        LOG.debug("Vhost user interface: {}, id: {} attributes read as: {}", key.getName(), index, builder);
     }
 }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanCustomizer.java
index 579136085..555d48c81 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanCustomizer.java
@@ -24,6 +24,10 @@ import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.VxlanTunnelDetails;
+import io.fd.vpp.jvpp.core.dto.VxlanTunnelDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.VxlanTunnelDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Arrays;
@@ -42,11 +46,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.VxlanTunnelDetails;
-import io.fd.vpp.jvpp.core.dto.VxlanTunnelDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.VxlanTunnelDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -77,61 +76,57 @@ public class VxlanCustomizer extends FutureJVppCustomizer
     public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id,
                                       @Nonnull final VxlanBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
-        try {
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
-            if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, VxlanTunnel.class, LOG)) {
-                return;
-            }
-
-            LOG.debug("Reading attributes for vxlan tunnel: {}", key.getName());
-            // Dump just a single
-            final VxlanTunnelDump request = new VxlanTunnelDump();
-            request.swIfIndex = index;
-
-            final CompletionStage<VxlanTunnelDetailsReplyDump> swInterfaceVxlanDetailsReplyDumpCompletionStage =
-                    getFutureJVpp().vxlanTunnelDump(request);
-            final VxlanTunnelDetailsReplyDump reply =
-                    getReplyForRead(swInterfaceVxlanDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
-
-            // VPP keeps vxlan tunnel interfaces even after they were deleted (optimization)
-            // However there ar no longer any vxlan tunnel specific fields assigned to it and this call
-            // returns nothing
-            if (reply == null || reply.vxlanTunnelDetails == null || reply.vxlanTunnelDetails.isEmpty()) {
-                LOG.debug(
-                        "Vxlan tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
-                                "after delete", key.getName(), index);
-                return;
-            }
-
-            checkState(reply.vxlanTunnelDetails.size() == 1,
-                    "Unexpected number of returned vxlan tunnels: {} for tunnel: {}", reply.vxlanTunnelDetails,
-                    key.getName());
-            LOG.trace("Vxlan tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
-
-            final VxlanTunnelDetails swInterfaceVxlanDetails = reply.vxlanTunnelDetails.get(0);
-            if (swInterfaceVxlanDetails.isIpv6 == 1) {
-                final Ipv6Address dstIpv6 =
-                        new Ipv6Address(parseAddress(swInterfaceVxlanDetails.dstAddress).getHostAddress());
-                builder.setDst(new IpAddress(dstIpv6));
-                final Ipv6Address srcIpv6 =
-                        new Ipv6Address(parseAddress(swInterfaceVxlanDetails.srcAddress).getHostAddress());
-                builder.setSrc(new IpAddress(srcIpv6));
-            } else {
-                final byte[] dstBytes = Arrays.copyOfRange(swInterfaceVxlanDetails.dstAddress, 0, 4);
-                final Ipv4Address dstIpv4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
-                builder.setDst(new IpAddress(dstIpv4));
-                final byte[] srcBytes = Arrays.copyOfRange(swInterfaceVxlanDetails.srcAddress, 0, 4);
-                final Ipv4Address srcIpv4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
-                builder.setSrc(new IpAddress(srcIpv4));
-            }
-            builder.setEncapVrfId((long) swInterfaceVxlanDetails.encapVrfId);
-            builder.setVni(new VxlanVni((long) swInterfaceVxlanDetails.vni));
-            LOG.debug("Vxlan tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
-        } catch (VppBaseCallException e) {
-            LOG.warn("Failed to readCurrentAttributes for: {}", id);
-            throw new ReadFailedException(id, e);
+
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
+        if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, VxlanTunnel.class, LOG)) {
+            return;
+        }
+
+        LOG.debug("Reading attributes for vxlan tunnel: {}", key.getName());
+        // Dump just a single
+        final VxlanTunnelDump request = new VxlanTunnelDump();
+        request.swIfIndex = index;
+
+        final CompletionStage<VxlanTunnelDetailsReplyDump> swInterfaceVxlanDetailsReplyDumpCompletionStage =
+                getFutureJVpp().vxlanTunnelDump(request);
+        final VxlanTunnelDetailsReplyDump reply =
+                getReplyForRead(swInterfaceVxlanDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
+
+        // VPP keeps vxlan tunnel interfaces even after they were deleted (optimization)
+        // However there ar no longer any vxlan tunnel specific fields assigned to it and this call
+        // returns nothing
+        if (reply == null || reply.vxlanTunnelDetails == null || reply.vxlanTunnelDetails.isEmpty()) {
+            LOG.debug(
+                    "Vxlan tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
+                            "after delete", key.getName(), index);
+            return;
+        }
+
+        checkState(reply.vxlanTunnelDetails.size() == 1,
+                "Unexpected number of returned vxlan tunnels: {} for tunnel: {}", reply.vxlanTunnelDetails,
+                key.getName());
+        LOG.trace("Vxlan tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
+
+        final VxlanTunnelDetails swInterfaceVxlanDetails = reply.vxlanTunnelDetails.get(0);
+        if (swInterfaceVxlanDetails.isIpv6 == 1) {
+            final Ipv6Address dstIpv6 =
+                    new Ipv6Address(parseAddress(swInterfaceVxlanDetails.dstAddress).getHostAddress());
+            builder.setDst(new IpAddress(dstIpv6));
+            final Ipv6Address srcIpv6 =
+                    new Ipv6Address(parseAddress(swInterfaceVxlanDetails.srcAddress).getHostAddress());
+            builder.setSrc(new IpAddress(srcIpv6));
+        } else {
+            final byte[] dstBytes = Arrays.copyOfRange(swInterfaceVxlanDetails.dstAddress, 0, 4);
+            final Ipv4Address dstIpv4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
+            builder.setDst(new IpAddress(dstIpv4));
+            final byte[] srcBytes = Arrays.copyOfRange(swInterfaceVxlanDetails.srcAddress, 0, 4);
+            final Ipv4Address srcIpv4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
+            builder.setSrc(new IpAddress(srcIpv4));
         }
+        builder.setEncapVrfId((long) swInterfaceVxlanDetails.encapVrfId);
+        builder.setVni(new VxlanVni((long) swInterfaceVxlanDetails.vni));
+        LOG.debug("Vxlan tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
     }
 
     @Nonnull
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanGpeCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanGpeCustomizer.java
index 8ea95c190..764054d55 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanGpeCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/VxlanGpeCustomizer.java
@@ -24,6 +24,10 @@ import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDetails;
+import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Arrays;
@@ -43,11 +47,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDetails;
-import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.VxlanGpeTunnelDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -78,64 +77,60 @@ public class VxlanGpeCustomizer extends FutureJVppCustomizer
     public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id,
                                       @Nonnull final VxlanGpeBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
-        try {
-            final InterfaceKey key = id.firstKeyOf(Interface.class);
-            final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
-            if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, VxlanGpeTunnel.class, LOG)) {
-                return;
-            }
-
-            LOG.debug("Reading attributes for VxlanGpe tunnel: {}", key.getName());
-            // Dump just a single
-            final VxlanGpeTunnelDump request = new VxlanGpeTunnelDump();
-            request.swIfIndex = index;
-
-            final CompletionStage<VxlanGpeTunnelDetailsReplyDump> swInterfaceVxlanGpeDetailsReplyDumpCompletionStage =
-                    getFutureJVpp().vxlanGpeTunnelDump(request);
-            final VxlanGpeTunnelDetailsReplyDump reply =
-                    getReplyForRead(swInterfaceVxlanGpeDetailsReplyDumpCompletionStage.toCompletableFuture(),
-                            id);
-
-            // VPP keeps VxlanGpe tunnel interfaces even after they were deleted (optimization)
-            // However there are no longer any VxlanGpe tunnel specific fields assigned to it and this call
-            // returns nothing
-            if (reply == null || reply.vxlanGpeTunnelDetails == null || reply.vxlanGpeTunnelDetails.isEmpty()) {
-                LOG.debug(
-                        "VxlanGpe tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
-                                "after delete", key.getName(), index);
-                return;
-            }
-
-            checkState(reply.vxlanGpeTunnelDetails.size() == 1,
-                    "Unexpected number of returned VxlanGpe tunnels: {} for tunnel: {}", reply.vxlanGpeTunnelDetails,
-                    key.getName());
-            LOG.trace("VxlanGpe tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
-
-            final VxlanGpeTunnelDetails swInterfaceVxlanGpeDetails = reply.vxlanGpeTunnelDetails.get(0);
-            if (swInterfaceVxlanGpeDetails.isIpv6 == 1) {
-                final Ipv6Address remote6 =
-                        new Ipv6Address(parseAddress(swInterfaceVxlanGpeDetails.remote).getHostAddress());
-                builder.setRemote(new IpAddress(remote6));
-                final Ipv6Address local6 =
-                        new Ipv6Address(parseAddress(swInterfaceVxlanGpeDetails.local).getHostAddress());
-                builder.setLocal(new IpAddress(local6));
-            } else {
-                final byte[] dstBytes = Arrays.copyOfRange(swInterfaceVxlanGpeDetails.remote, 0, 4);
-                final Ipv4Address remote4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
-                builder.setRemote(new IpAddress(remote4));
-                final byte[] srcBytes = Arrays.copyOfRange(swInterfaceVxlanGpeDetails.local, 0, 4);
-                final Ipv4Address local4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
-                builder.setLocal(new IpAddress(local4));
-            }
-            builder.setVni(new VxlanGpeVni((long) swInterfaceVxlanGpeDetails.vni));
-            builder.setNextProtocol(VxlanGpeNextProtocol.forValue(swInterfaceVxlanGpeDetails.protocol));
-            builder.setEncapVrfId((long) swInterfaceVxlanGpeDetails.encapVrfId);
-            builder.setDecapVrfId((long) swInterfaceVxlanGpeDetails.decapVrfId);
-            LOG.debug("VxlanGpe tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
-        } catch (VppBaseCallException e) {
-            LOG.warn("Failed to readCurrentAttributes for: {}", id);
-            throw new ReadFailedException(id, e);
+
+        final InterfaceKey key = id.firstKeyOf(Interface.class);
+        final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext());
+        if (!isInterfaceOfType(getFutureJVpp(), ctx.getModificationCache(), id, index, VxlanGpeTunnel.class, LOG)) {
+            return;
+        }
+
+        LOG.debug("Reading attributes for VxlanGpe tunnel: {}", key.getName());
+        // Dump just a single
+        final VxlanGpeTunnelDump request = new VxlanGpeTunnelDump();
+        request.swIfIndex = index;
+
+        final CompletionStage<VxlanGpeTunnelDetailsReplyDump> swInterfaceVxlanGpeDetailsReplyDumpCompletionStage =
+                getFutureJVpp().vxlanGpeTunnelDump(request);
+        final VxlanGpeTunnelDetailsReplyDump reply =
+                getReplyForRead(swInterfaceVxlanGpeDetailsReplyDumpCompletionStage.toCompletableFuture(),
+                        id);
+
+        // VPP keeps VxlanGpe tunnel interfaces even after they were deleted (optimization)
+        // However there are no longer any VxlanGpe tunnel specific fields assigned to it and this call
+        // returns nothing
+        if (reply == null || reply.vxlanGpeTunnelDetails == null || reply.vxlanGpeTunnelDetails.isEmpty()) {
+            LOG.debug(
+                    "VxlanGpe tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" +
+                            "after delete", key.getName(), index);
+            return;
+        }
+
+        checkState(reply.vxlanGpeTunnelDetails.size() == 1,
+                "Unexpected number of returned VxlanGpe tunnels: {} for tunnel: {}", reply.vxlanGpeTunnelDetails,
+                key.getName());
+        LOG.trace("VxlanGpe tunnel: {} attributes returned from VPP: {}", key.getName(), reply);
+
+        final VxlanGpeTunnelDetails swInterfaceVxlanGpeDetails = reply.vxlanGpeTunnelDetails.get(0);
+        if (swInterfaceVxlanGpeDetails.isIpv6 == 1) {
+            final Ipv6Address remote6 =
+                    new Ipv6Address(parseAddress(swInterfaceVxlanGpeDetails.remote).getHostAddress());
+            builder.setRemote(new IpAddress(remote6));
+            final Ipv6Address local6 =
+                    new Ipv6Address(parseAddress(swInterfaceVxlanGpeDetails.local).getHostAddress());
+            builder.setLocal(new IpAddress(local6));
+        } else {
+            final byte[] dstBytes = Arrays.copyOfRange(swInterfaceVxlanGpeDetails.remote, 0, 4);
+            final Ipv4Address remote4 = new Ipv4Address(parseAddress(dstBytes).getHostAddress());
+            builder.setRemote(new IpAddress(remote4));
+            final byte[] srcBytes = Arrays.copyOfRange(swInterfaceVxlanGpeDetails.local, 0, 4);
+            final Ipv4Address local4 = new Ipv4Address(parseAddress(srcBytes).getHostAddress());
+            builder.setLocal(new IpAddress(local4));
         }
+        builder.setVni(new VxlanGpeVni((long) swInterfaceVxlanGpeDetails.vni));
+        builder.setNextProtocol(VxlanGpeNextProtocol.forValue(swInterfaceVxlanGpeDetails.protocol));
+        builder.setEncapVrfId((long) swInterfaceVxlanGpeDetails.encapVrfId);
+        builder.setDecapVrfId((long) swInterfaceVxlanGpeDetails.decapVrfId);
+        LOG.debug("VxlanGpe tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder);
     }
 
     @Nonnull
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/AclCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/AclCustomizer.java
index c248575ca..091244eea 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/AclCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/AclCustomizer.java
@@ -26,7 +26,6 @@ import io.fd.honeycomb.translate.v3po.vppclassifier.VppClassifierContextManager;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
-import io.fd.vpp.jvpp.VppBaseCallException;
 import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterface;
 import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterfaceReply;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
@@ -71,7 +70,8 @@ public class AclCustomizer extends FutureJVppCustomizer
     }
 
     @Override
-    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final IngressBuilder builder,
+    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
+                                      @Nonnull final IngressBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
         LOG.debug("Reading attributes for interface ACL: {}", id);
         final InterfaceKey interfaceKey = id.firstKeyOf(Interface.class);
@@ -79,19 +79,16 @@ public class AclCustomizer extends FutureJVppCustomizer
 
         final ClassifyTableByInterface request = new ClassifyTableByInterface();
         request.swIfIndex = interfaceContext.getIndex(interfaceKey.getName(), ctx.getMappingContext());
-        try {
-            final ClassifyTableByInterfaceReply reply =
-                    getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id);
 
-            builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext()));
-            builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext()));
-            builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext()));
+        final ClassifyTableByInterfaceReply reply =
+                getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id);
 
-            if (LOG.isTraceEnabled()) {
-                LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build());
-            }
-        } catch (VppBaseCallException e) {
-            throw new ReadFailedException(id, e);
+        builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext()));
+        builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext()));
+        builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext()));
+
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build());
         }
     }
 }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/SubInterfaceAclCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/SubInterfaceAclCustomizer.java
index ad80f6ee2..de287cf67 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/SubInterfaceAclCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/acl/ingress/SubInterfaceAclCustomizer.java
@@ -27,7 +27,6 @@ import io.fd.honeycomb.translate.v3po.vppclassifier.VppClassifierContextManager;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
-import io.fd.vpp.jvpp.VppBaseCallException;
 import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterface;
 import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterfaceReply;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
@@ -74,7 +73,8 @@ public class SubInterfaceAclCustomizer extends FutureJVppCustomizer
     }
 
     @Override
-    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final IngressBuilder builder,
+    public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
+                                      @Nonnull final IngressBuilder builder,
                                       @Nonnull final ReadContext ctx) throws ReadFailedException {
         LOG.debug("Reading attributes for sub-interface ACL: {}", id);
         final InterfaceKey parentInterfacekey = id.firstKeyOf(Interface.class);
@@ -86,19 +86,16 @@ public class SubInterfaceAclCustomizer extends FutureJVppCustomizer
 
         final ClassifyTableByInterface request = new ClassifyTableByInterface();
         request.swIfIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
-        try {
-            final ClassifyTableByInterfaceReply reply =
-                    getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id);
 
-            builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext()));
-            builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext()));
-            builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext()));
+        final ClassifyTableByInterfaceReply reply =
+                getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id);
 
-            if (LOG.isTraceEnabled()) {
-                LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build());
-            }
-        } catch (VppBaseCallException e) {
-            throw new ReadFailedException(id, e);
+        builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext()));
+        builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext()));
+        builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext()));
+
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build());
         }
     }
 }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/Ipv4AddressCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/Ipv4AddressCustomizer.java
index bba2cf590..f07ef3d57 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/Ipv4AddressCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/Ipv4AddressCustomizer.java
@@ -23,11 +23,13 @@ import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
 import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
 import io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump.AddressDumpExecutor;
 import io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump.params.AddressDumpParams;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.List;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@@ -39,9 +41,6 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev14061
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -80,14 +79,8 @@ public class Ipv4AddressCustomizer extends FutureJVppCustomizer
 
         final String interfaceName = id.firstKeyOf(Interface.class).getName();
         final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
-        final Optional<IpAddressDetailsReplyDump> dumpOptional;
-        try {
-            dumpOptional =
-                    dumpManager.getDump(CACHE_KEY, ctx.getModificationCache(),
-                            new AddressDumpParams(interfaceIndex, false));
-        } catch (DumpExecutionFailedException e) {
-            throw new ReadFailedException(id, e);
-        }
+        final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
+                .getDump(id, CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(interfaceIndex, false));
 
         if (!dumpOptional.isPresent() || dumpOptional.get().ipAddressDetails.isEmpty()) {
             return;
@@ -115,14 +108,8 @@ public class Ipv4AddressCustomizer extends FutureJVppCustomizer
 
         final String interfaceName = id.firstKeyOf(Interface.class).getName();
         final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
-        final Optional<IpAddressDetailsReplyDump> dumpOptional;
-        try {
-            dumpOptional =
-                    dumpManager.getDump(CACHE_KEY, ctx.getModificationCache(),
-                            new AddressDumpParams(interfaceIndex, false));
-        } catch (DumpExecutionFailedException e) {
-            throw new ReadFailedException(id, e);
-        }
+        final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
+                .getDump(id, CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(interfaceIndex, false));
 
         return getAllIpv4AddressIds(dumpOptional, AddressKey::new);
     }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/SubInterfaceIpv4AddressCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/SubInterfaceIpv4AddressCustomizer.java
index 06682b641..234270883 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/SubInterfaceIpv4AddressCustomizer.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/SubInterfaceIpv4AddressCustomizer.java
@@ -23,12 +23,14 @@ import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
 import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
 import io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump.AddressDumpExecutor;
 import io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump.params.AddressDumpParams;
 import io.fd.honeycomb.translate.vpp.util.FutureJVppCustomizer;
 import io.fd.honeycomb.translate.vpp.util.NamingContext;
 import io.fd.honeycomb.translate.vpp.util.SubInterfaceUtils;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.util.List;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@@ -41,9 +43,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
-import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,14 +81,8 @@ public class SubInterfaceIpv4AddressCustomizer extends FutureJVppCustomizer
 
         final String subInterfaceName = getSubInterfaceName(id);
         final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
-        final Optional<IpAddressDetailsReplyDump> dumpOptional;
-        try {
-            dumpOptional = dumpManager
-                    .getDump(CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(subInterfaceIndex, false));
-        } catch (DumpExecutionFailedException e) {
-            throw new ReadFailedException(id, e);
-        }
-
+        final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
+                .getDump(id, CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(subInterfaceIndex, false));
 
         final Optional<IpAddressDetails> ipAddressDetails =
                 findIpAddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
@@ -113,13 +106,8 @@ public class SubInterfaceIpv4AddressCustomizer extends FutureJVppCustomizer
 
         final String subInterfaceName = getSubInterfaceName(id);
         final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
-        final Optional<IpAddressDetailsReplyDump> dumpOptional;
-        try {
-            dumpOptional = dumpManager
-                    .getDump(CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(subInterfaceIndex, false));
-        } catch (DumpExecutionFailedException e) {
-            throw new ReadFailedException(id, e);
-        }
+        final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
+                .getDump(id, CACHE_KEY, ctx.getModificationCache(), new AddressDumpParams(subInterfaceIndex, false));
 
         return getAllIpv4AddressIds(dumpOptional, AddressKey::new);
     }
diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/dump/AddressDumpExecutor.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/dump/AddressDumpExecutor.java
index 20fda0405..764717db4 100644
--- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/dump/AddressDumpExecutor.java
+++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/ip/dump/AddressDumpExecutor.java
@@ -3,19 +3,16 @@ package io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import io.fd.honeycomb.translate.read.ReadFailedException;
 import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
-import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
-import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
 import io.fd.honeycomb.translate.v3po.interfacesstate.ip.dump.params.AddressDumpParams;
 import io.fd.honeycomb.translate.vpp.util.ByteDataTranslator;
 import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer;
-import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnull;
-import io.fd.vpp.jvpp.VppBaseCallException;
 import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
 import io.fd.vpp.jvpp.core.dto.IpAddressDump;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public class AddressDumpExecutor
         implements EntityDumpExecutor<IpAddressDetailsReplyDump, AddressDumpParams>, ByteDataTranslator,
@@ -28,20 +25,15 @@ public class AddressDumpExecutor
     }
 
     @Override
-    public IpAddressDetailsReplyDump executeDump(final AddressDumpParams params) throws DumpExecutionFailedException {
+    @Nonnull
+    public IpAddressDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final AddressDumpParams params)
+            throws ReadFailedException {
         checkNotNull(params, "Address dump params cannot be null");
 
         IpAddressDump dumpRequest = new IpAddressDump();
         dumpRequest.isIpv6 = booleanToByte(params.isIpv6());
         dumpRequest.swIfIndex = params.getInterfaceIndex();
 
-        try {
-            return getReply(vppApi.ipAddressDump(dumpRequest).toCompletableFuture());
-        } catch (TimeoutException e) {
-            throw DumpTimeoutException
-                    .wrapTimeoutException("Dumping or addresses ended in timeout[params : ]" + params, e);
-        } catch (VppBaseCallException e) {
-            throw DumpCallFailedException.wrapFailedCallException("Dumping of addresses failed[params : ]" + params, e);
-        }
+        return getReplyForRead(vppApi.ipAddressDump(dumpRequest).toCompletableFuture(), identifier);
     }
 }