HC2VPP-105: add support for nat64 pool read

Change-Id: If458e0b812435de5ae41af1bdbf53e2ffaf94e35
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>

3 files changed, 186 insertions, 82 deletions

diff --git a/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizer.java b/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizer.java
index 1a6742648..451c694d1 100644
--- a/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizer.java
+++ b/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizer.java
@@ -16,6 +16,8 @@
 
 package io.fd.hc2vpp.nat.read;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
 import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.read.ReadContext;
@@ -24,7 +26,9 @@ import io.fd.honeycomb.translate.spi.read.Initialized;
 import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
 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.snat.dto.Nat64PoolAddrDetails;
+import io.fd.vpp.jvpp.snat.dto.Nat64PoolAddrDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.dto.Nat64PoolAddrDump;
 import io.fd.vpp.jvpp.snat.dto.SnatAddressDetails;
 import io.fd.vpp.jvpp.snat.dto.SnatAddressDetailsReplyDump;
 import io.fd.vpp.jvpp.snat.dto.SnatAddressDump;
@@ -41,6 +45,9 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev1509
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.NatInstance;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.NatInstanceKey;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.nat.instance.NatCurrentConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.ExternalIpAddressPoolStateAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.ExternalIpAddressPoolStateAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.NatPoolType;
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@@ -53,10 +60,29 @@ final class ExternalIpPoolCustomizer implements
 
     private static final Logger LOG = LoggerFactory.getLogger(ExternalIpPoolCustomizer.class);
 
-    private final DumpCacheManager<SnatAddressDetailsReplyDump, Void> dumpMgr;
+    private final DumpCacheManager<SnatAddressDetailsReplyDump, Void> nat44DumpMgr;
+    private final DumpCacheManager<Nat64PoolAddrDetailsReplyDump, Void> nat64DumpMgr;
+
+    ExternalIpPoolCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat) {
+        checkNotNull(jvppSnat, "jvppSnat should not be null");
+        this.nat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatAddressDetailsReplyDump, Void>()
+                .withExecutor((id, params) -> getReplyForRead(jvppSnat.snatAddressDump(new SnatAddressDump()).toCompletableFuture(), id))
+                .acceptOnly(SnatAddressDetailsReplyDump.class)
+                .build();
+        this.nat64DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat64PoolAddrDetailsReplyDump, Void>()
+                .withExecutor((id, params) -> getReplyForRead(jvppSnat.nat64PoolAddrDump(new Nat64PoolAddrDump()).toCompletableFuture(), id))
+                .acceptOnly(Nat64PoolAddrDetailsReplyDump.class)
+                .build();
+    }
+
+    private static void setPoolType(@Nonnull final ExternalIpAddressPoolBuilder builder, final NatPoolType poolType) {
+        builder.addAugmentation(ExternalIpAddressPoolStateAugmentation.class,
+                new ExternalIpAddressPoolStateAugmentationBuilder().setPoolType(poolType).build());
+    }
 
-    ExternalIpPoolCustomizer(final DumpCacheManager<SnatAddressDetailsReplyDump, Void> dumpMgr) {
-        this.dumpMgr = dumpMgr;
+    static InstanceIdentifier<ExternalIpAddressPool> getCfgId(final @Nonnull InstanceIdentifier<ExternalIpAddressPool> id) {
+        return NatInstanceCustomizer.getCfgId(RWUtils.cutId(id, NatInstance.class))
+                .child(ExternalIpAddressPool.class, id.firstKeyOf(ExternalIpAddressPool.class));
     }
 
     @Nonnull
@@ -72,16 +98,42 @@ final class ExternalIpPoolCustomizer implements
         LOG.trace("Reading current attributes for external IP pool: {}", id);
 
         final Long poolId = id.firstKeyOf(ExternalIpAddressPool.class).getPoolId();
-        final SnatAddressDetails details =
-                dumpMgr.getDump(id, ctx.getModificationCache(), null)
-                        .or(new SnatAddressDetailsReplyDump()).snatAddressDetails.get(Math.toIntExact(poolId));
+        final List<SnatAddressDetails> nat44Details =
+                nat44DumpMgr.getDump(id, ctx.getModificationCache(), null)
+                        .or(new SnatAddressDetailsReplyDump()).snatAddressDetails;
+        final int nat44PoolCount = nat44Details.size();
+
+        // Uses ID<->address mapping as defined by getAllIds (nat44 mappings go before nat64):
+        if (poolId < nat44PoolCount) {
+            final SnatAddressDetails detail = nat44Details.get(Math.toIntExact(poolId));
+            readPoolIp(builder, detail.ipAddress);
+            setPoolType(builder, NatPoolType.Nat44);
+        } else {
+            final List<Nat64PoolAddrDetails> nat64Details = nat64DumpMgr.getDump(id, ctx.getModificationCache(), null)
+                    .or(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails;
+            final int nat64PoolCount = nat64Details.size();
+            final int nat64PoolPosition = Math.toIntExact(poolId) - nat44PoolCount;
+            if (nat64PoolPosition < nat64PoolCount) {
+                final Nat64PoolAddrDetails detail = nat64Details.get(nat64PoolPosition);
+                readPoolIp(builder, detail.address);
+                setPoolType(builder, NatPoolType.Nat64);
+            } else {
+                // Address pool for given ID is missing (legal state).
+                // Pool ID is computed based on data obtained by nat44 & nat64 dumps (see getAllIds for more info).
+                // IP address might get different poolId in two consecutive reads even if it was not modified in between.
+                LOG.trace("External IP pool: {} not found (nat44PoolCount={}, nat64PoolCount={})", id, nat44PoolCount, nat64PoolCount);
+                return;
+            }
+        }
 
-        builder.setExternalIpPool(new Ipv4Prefix(arrayToIpv4AddressNoZone(details.ipAddress).getValue() + "/32"));
         builder.setPoolId(poolId);
-
         LOG.trace("External IP pool: {}. Read as: {}", id, builder);
     }
 
+    private void readPoolIp(@Nonnull final ExternalIpAddressPoolBuilder builder, @Nonnull final byte[] address) {
+        builder.setExternalIpPool(new Ipv4Prefix(arrayToIpv4AddressNoZone(address).getValue() + "/32"));
+    }
+
     @Nonnull
     @Override
     public List<ExternalIpAddressPoolKey> getAllIds(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id,
@@ -100,10 +152,17 @@ final class ExternalIpPoolCustomizer implements
         // That's why the write and read is not symmetrical in terms of data structure, instead,
         // this customizer also returns every single address as a 32 prefix and assigns an artificial key to them
 
-        final long addressCount = dumpMgr.getDump(id, ctx.getModificationCache(), null)
+        long addressCount = nat44DumpMgr.getDump(id, ctx.getModificationCache(), null)
                 .or(new SnatAddressDetailsReplyDump()).snatAddressDetails.stream()
                 .count();
 
+        // The ietf-nat model groups address pools for Nat44 and Nat64 under the same list,
+        // but VPP uses different APIs, so we need an other dump:
+
+        addressCount += nat64DumpMgr.getDump(id, ctx.getModificationCache(), null)
+                .or(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails.stream()
+                .count();
+
         final List<ExternalIpAddressPoolKey> ids = LongStream.range(0, addressCount)
                 .mapToObj(ExternalIpAddressPoolKey::new)
                 .collect(Collectors.toList());
@@ -125,25 +184,4 @@ final class ExternalIpPoolCustomizer implements
             @Nonnull final ReadContext ctx) {
         return Initialized.create(getCfgId(id), readValue);
     }
-
-    static InstanceIdentifier<ExternalIpAddressPool> getCfgId(final @Nonnull InstanceIdentifier<ExternalIpAddressPool> id) {
-        return NatInstanceCustomizer.getCfgId(RWUtils.cutId(id, NatInstance.class))
-                .child(ExternalIpAddressPool.class, id.firstKeyOf(ExternalIpAddressPool.class));
-    }
-
-    static final class AddressRangeDumpExecutor implements EntityDumpExecutor<SnatAddressDetailsReplyDump, Void>,
-            JvppReplyConsumer {
-        private final FutureJVppSnatFacade jvppSnat;
-
-        AddressRangeDumpExecutor(final FutureJVppSnatFacade jvppSnat) {
-            this.jvppSnat = jvppSnat;
-        }
-
-        @Nonnull
-        @Override
-        public SnatAddressDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final Void params)
-                throws ReadFailedException {
-            return getReplyForRead(jvppSnat.snatAddressDump(new SnatAddressDump()).toCompletableFuture(), identifier);
-        }
-    }
 }
diff --git a/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/NatReaderFactory.java b/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/NatReaderFactory.java
index 497ed1c96..791b7bc0b 100644
--- a/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/NatReaderFactory.java
+++ b/nat/nat2vpp/src/main/java/io/fd/hc2vpp/nat/read/NatReaderFactory.java
@@ -23,7 +23,6 @@ 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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatAddressDetailsReplyDump;
 import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
 import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
 import javax.annotation.Nonnull;
@@ -52,26 +51,21 @@ public class NatReaderFactory implements ReaderFactory {
     private static final InstanceIdentifier<MappingTable> MAP_TABLE_ID = NAT_INSTANCE_ID.child(MappingTable.class);
     private static final InstanceIdentifier<MappingEntry> MAP_ENTRY_ID = MAP_TABLE_ID.child(MappingEntry.class);
 
+    private final FutureJVppSnatFacade jvppSnat;
     private final MappingEntryContext mappingEntryContext;
     private final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> mapEntryDumpMgr;
-    private final DumpCacheManager<SnatAddressDetailsReplyDump, Void> addressRangeDumpMgr;
 
 
     @Inject
     public NatReaderFactory(final FutureJVppSnatFacade jvppSnat,
                             final MappingEntryContext mappingEntryContext) {
+        this.jvppSnat = jvppSnat;
         this.mappingEntryContext = mappingEntryContext;
         this.mapEntryDumpMgr =
                 new DumpCacheManager.DumpCacheManagerBuilder<SnatStaticMappingDetailsReplyDump, Void>()
                         .withExecutor(new MappingEntryCustomizer.MappingEntryDumpExecutor(jvppSnat))
                         .acceptOnly(SnatStaticMappingDetailsReplyDump.class)
                         .build();
-
-        this.addressRangeDumpMgr =
-                new DumpCacheManager.DumpCacheManagerBuilder<SnatAddressDetailsReplyDump, Void>()
-                        .withExecutor(new ExternalIpPoolCustomizer.AddressRangeDumpExecutor(jvppSnat))
-                        .acceptOnly(SnatAddressDetailsReplyDump.class)
-                        .build();
     }
 
     @Override
@@ -87,6 +81,6 @@ public class NatReaderFactory implements ReaderFactory {
 
         registry.addStructuralReader(CURRENT_CONFIG, NatCurrentConfigBuilder.class);
         registry.add(new GenericInitListReader<>(CURRENT_CONFIG.child(ExternalIpAddressPool.class),
-                new ExternalIpPoolCustomizer(addressRangeDumpMgr)));
+                new ExternalIpPoolCustomizer(jvppSnat)));
     }
 }
diff --git a/nat/nat2vpp/src/test/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizerTest.java b/nat/nat2vpp/src/test/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizerTest.java
index 8413bce30..e6dfeb86f 100644
--- a/nat/nat2vpp/src/test/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizerTest.java
+++ b/nat/nat2vpp/src/test/java/io/fd/hc2vpp/nat/read/ExternalIpPoolCustomizerTest.java
@@ -20,14 +20,18 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 import static org.hamcrest.core.IsCollectionContaining.hasItems;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.NatPoolType.Nat44;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.NatPoolType.Nat64;
 
 import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
 import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.vpp.jvpp.snat.dto.Nat64PoolAddrDetails;
+import io.fd.vpp.jvpp.snat.dto.Nat64PoolAddrDetailsReplyDump;
 import io.fd.vpp.jvpp.snat.dto.SnatAddressDetails;
 import io.fd.vpp.jvpp.snat.dto.SnatAddressDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.LongStream;
@@ -41,99 +45,167 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev1509
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.NatInstanceKey;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.nat.instance.NatCurrentConfig;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.state.nat.instances.nat.instance.NatCurrentConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.nat.rev170804.ExternalIpAddressPoolStateAugmentation;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public class ExternalIpPoolCustomizerTest
     extends ListReaderCustomizerTest<ExternalIpAddressPool, ExternalIpAddressPoolKey, ExternalIpAddressPoolBuilder> {
 
-    private InstanceIdentifier<ExternalIpAddressPool> externalPoolIdDefaultNatInstance;
-    private InstanceIdentifier<ExternalIpAddressPool> externalPoolIdDifferentNatInstance;
-    private DumpCacheManager<SnatAddressDetailsReplyDump, Void> dumpCacheManager;
+    private static final InstanceIdentifier<NatCurrentConfig> NAT_CONFIG_ID =
+            InstanceIdentifier.create(NatInstances.class)
+                    .child(NatInstance.class, new NatInstanceKey(NatInstanceCustomizer.DEFAULT_VRF_ID))
+                    .child(NatCurrentConfig.class);
+
+    private static final InstanceIdentifier<ExternalIpAddressPool> NAT_DEFAULT_POOL_WILDCARDED_ID =
+            NAT_CONFIG_ID.child(ExternalIpAddressPool.class);
+
+    private static final InstanceIdentifier<ExternalIpAddressPool> NAT_NON_DEFAULT_POOL_WILDCARDED_ID =
+            InstanceIdentifier.create(NatInstances.class).child(NatInstance.class, new NatInstanceKey(7L))
+                    .child(NatCurrentConfig.class).child(ExternalIpAddressPool.class);
 
     @Mock
-    private EntityDumpExecutor<SnatAddressDetailsReplyDump, Void> executor;
+    private FutureJVppSnatFacade jvppSnat;
 
     public ExternalIpPoolCustomizerTest() {
         super(ExternalIpAddressPool.class, NatCurrentConfigBuilder.class);
     }
 
     @Override
-    protected void setUp() throws Exception {
-        externalPoolIdDefaultNatInstance = InstanceIdentifier
-            .create(NatInstances.class)
-            .child(NatInstance.class, new NatInstanceKey(NatInstanceCustomizer.DEFAULT_VRF_ID))
-            .child(NatCurrentConfig.class)
-            .child(ExternalIpAddressPool.class, new ExternalIpAddressPoolKey(2L));
-
-        externalPoolIdDifferentNatInstance = InstanceIdentifier
-            .create(NatInstances.class)
-            .child(NatInstance.class, new NatInstanceKey(7L))
-            .child(NatCurrentConfig.class)
-            .child(ExternalIpAddressPool.class, new ExternalIpAddressPoolKey(2L));
-
-        dumpCacheManager = new DumpCacheManager.DumpCacheManagerBuilder<SnatAddressDetailsReplyDump, Void>()
-            .withExecutor(executor)
-            .acceptOnly(SnatAddressDetailsReplyDump.class)
-            .build();
+    protected ReaderCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolBuilder> initCustomizer() {
+        return new ExternalIpPoolCustomizer(jvppSnat);
     }
 
-    @Override
-    protected ReaderCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolBuilder> initCustomizer() {
-        return new ExternalIpPoolCustomizer(dumpCacheManager);
+    @Test
+    public void testReadAttributesNat44() throws Exception {
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+        final long poolId = 2;
+        final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
+        getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx);
+
+        assertEquals("192.168.44.3/32", builder.getExternalIpPool().getValue());
+        assertEquals(poolId, builder.getPoolId().longValue());
+        assertEquals(Nat44, builder.getAugmentation(ExternalIpAddressPoolStateAugmentation.class).getPoolType());
+    }
+
+    @Test
+    public void testReadAttributesNat64() throws Exception {
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+        final long poolId = 2;
+
+        final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
+        getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx);
+
+        assertEquals("192.168.64.3/32", builder.getExternalIpPool().getValue());
+        assertEquals(poolId, builder.getPoolId().longValue());
+        assertEquals(Nat64, builder.getAugmentation(ExternalIpAddressPoolStateAugmentation.class).getPoolType());
     }
 
     @Test
     public void testReadAttributes() throws Exception {
-        when(executor.executeDump(externalPoolIdDefaultNatInstance, null)).thenReturn(dumpReplyNonEmpty());
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+        final long poolId = 5;
 
         final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
-        getCustomizer().readCurrentAttributes(externalPoolIdDefaultNatInstance, builder, ctx);
+        getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx);
+
+        assertEquals("192.168.64.3/32", builder.getExternalIpPool().getValue());
+        assertEquals(poolId, builder.getPoolId().longValue());
+        assertEquals(Nat64, builder.getAugmentation(ExternalIpAddressPoolStateAugmentation.class).getPoolType());
+    }
+
+    @Test
+    public void testGetAllNat44() throws Exception {
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
 
-        assertEquals("192.168.2.3/32", builder.getExternalIpPool().getValue());
-        assertEquals(2L, builder.getPoolId().longValue());
+        final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
+        assertThat(allIds, hasItems(
+                LongStream.range(0, 2).mapToObj(ExternalIpAddressPoolKey::new)
+                        .toArray(ExternalIpAddressPoolKey[]::new)));
+    }
+
+    @Test
+    public void testGetAllNat64() throws Exception {
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+
+        final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
+        assertThat(allIds, hasItems(
+                LongStream.range(0, 2).mapToObj(ExternalIpAddressPoolKey::new)
+                        .toArray(ExternalIpAddressPoolKey[]::new)));
     }
 
     @Test
     public void testGetAll() throws Exception {
-        when(executor.executeDump(externalPoolIdDefaultNatInstance, null)).thenReturn(dumpReplyNonEmpty());
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
 
-        final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(externalPoolIdDefaultNatInstance, ctx);
+        final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
         assertThat(allIds, hasItems(
-            LongStream.range(0, 2).mapToObj(ExternalIpAddressPoolKey::new).toArray(ExternalIpAddressPoolKey[]::new)));
+                LongStream.range(0, 5).mapToObj(ExternalIpAddressPoolKey::new)
+                        .toArray(ExternalIpAddressPoolKey[]::new)));
     }
 
     @Test
     public void testGetAllDifferentInstance() throws Exception {
-        assertThat(getCustomizer().getAllIds(externalPoolIdDifferentNatInstance, ctx), empty());
+        assertThat(getCustomizer().getAllIds(NAT_NON_DEFAULT_POOL_WILDCARDED_ID, ctx), empty());
     }
 
     @Test
     public void testGetAllNoDump() throws Exception {
-        when(executor.executeDump(externalPoolIdDefaultNatInstance, null)).thenReturn(dumpReplyEmpty());
-        assertThat(getCustomizer().getAllIds(externalPoolIdDefaultNatInstance, ctx), empty());
+        when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+        when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
+        assertThat(getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx), empty());
+    }
+
+    private static InstanceIdentifier<ExternalIpAddressPool> getId(final long id) {
+        return NAT_CONFIG_ID.child(ExternalIpAddressPool.class, new ExternalIpAddressPoolKey(id));
     }
 
-    private static SnatAddressDetailsReplyDump dumpReplyEmpty() {
+    private static SnatAddressDetailsReplyDump dumpReplyNat44Empty() {
         return new SnatAddressDetailsReplyDump();
     }
 
-    private static SnatAddressDetailsReplyDump dumpReplyNonEmpty() {
-        SnatAddressDetailsReplyDump replyDump = dumpReplyEmpty();
+    private static SnatAddressDetailsReplyDump dumpReplyNat44NonEmpty() {
+        SnatAddressDetailsReplyDump replyDump = dumpReplyNat44Empty();
 
         SnatAddressDetails detailsOne = new SnatAddressDetails();
-        detailsOne.ipAddress = new byte[] {-64, -88, 2, 1};
+        detailsOne.ipAddress = new byte[]{-64, -88, 44, 1};
         detailsOne.isIp4 = 1;
 
         SnatAddressDetails detailsTwo = new SnatAddressDetails();
-        detailsTwo.ipAddress = new byte[] {-64, -88, 2, 2};
+        detailsTwo.ipAddress = new byte[]{-64, -88, 44, 2};
         detailsTwo.isIp4 = 1;
 
         SnatAddressDetails detailsThree = new SnatAddressDetails();
-        detailsThree.ipAddress = new byte[] {-64, -88, 2, 3};
+        detailsThree.ipAddress = new byte[]{-64, -88, 44, 3};
         detailsThree.isIp4 = 1;
 
         replyDump.snatAddressDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
 
         return replyDump;
     }
+
+    private static Nat64PoolAddrDetailsReplyDump dumpReplyNat64Empty() {
+        return new Nat64PoolAddrDetailsReplyDump();
+    }
+
+    private static Nat64PoolAddrDetailsReplyDump dumpReplyNat64NonEmpty() {
+        Nat64PoolAddrDetailsReplyDump replyDump = dumpReplyNat64Empty();
+
+        Nat64PoolAddrDetails detailsOne = new Nat64PoolAddrDetails();
+        detailsOne.address = new byte[]{-64, -88, 64, 1};
+
+        Nat64PoolAddrDetails detailsTwo = new Nat64PoolAddrDetails();
+        detailsTwo.address = new byte[]{-64, -88, 64, 2};
+
+        Nat64PoolAddrDetails detailsThree = new Nat64PoolAddrDetails();
+        detailsThree.address = new byte[]{-64, -88, 64, 3};
+
+        replyDump.nat64PoolAddrDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
+
+        return replyDump;
+    }
 }
\ No newline at end of file