From c4ec83562d4c4582be64de637e76826718e2beaa Mon Sep 17 00:00:00 2001 From: Marek Gradzki Date: Wed, 16 Aug 2017 10:37:55 +0200 Subject: HC2VPP-105: add support for nat64 pool read Change-Id: If458e0b812435de5ae41af1bdbf53e2ffaf94e35 Signed-off-by: Marek Gradzki --- .../hc2vpp/nat/read/ExternalIpPoolCustomizer.java | 100 +++++++++---- .../io/fd/hc2vpp/nat/read/NatReaderFactory.java | 12 +- .../nat/read/ExternalIpPoolCustomizerTest.java | 156 +++++++++++++++------ 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 dumpMgr; + private final DumpCacheManager nat44DumpMgr; + private final DumpCacheManager nat64DumpMgr; + + ExternalIpPoolCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat) { + checkNotNull(jvppSnat, "jvppSnat should not be null"); + this.nat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder() + .withExecutor((id, params) -> getReplyForRead(jvppSnat.snatAddressDump(new SnatAddressDump()).toCompletableFuture(), id)) + .acceptOnly(SnatAddressDetailsReplyDump.class) + .build(); + this.nat64DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder() + .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 dumpMgr) { - this.dumpMgr = dumpMgr; + static InstanceIdentifier getCfgId(final @Nonnull InstanceIdentifier 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 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 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 getAllIds(@Nonnull final InstanceIdentifier 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 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 getCfgId(final @Nonnull InstanceIdentifier id) { - return NatInstanceCustomizer.getCfgId(RWUtils.cutId(id, NatInstance.class)) - .child(ExternalIpAddressPool.class, id.firstKeyOf(ExternalIpAddressPool.class)); - } - - static final class AddressRangeDumpExecutor implements EntityDumpExecutor, - 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 MAP_TABLE_ID = NAT_INSTANCE_ID.child(MappingTable.class); private static final InstanceIdentifier MAP_ENTRY_ID = MAP_TABLE_ID.child(MappingEntry.class); + private final FutureJVppSnatFacade jvppSnat; private final MappingEntryContext mappingEntryContext; private final DumpCacheManager mapEntryDumpMgr; - private final DumpCacheManager addressRangeDumpMgr; @Inject public NatReaderFactory(final FutureJVppSnatFacade jvppSnat, final MappingEntryContext mappingEntryContext) { + this.jvppSnat = jvppSnat; this.mappingEntryContext = mappingEntryContext; this.mapEntryDumpMgr = new DumpCacheManager.DumpCacheManagerBuilder() .withExecutor(new MappingEntryCustomizer.MappingEntryDumpExecutor(jvppSnat)) .acceptOnly(SnatStaticMappingDetailsReplyDump.class) .build(); - - this.addressRangeDumpMgr = - new DumpCacheManager.DumpCacheManagerBuilder() - .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 { - private InstanceIdentifier externalPoolIdDefaultNatInstance; - private InstanceIdentifier externalPoolIdDifferentNatInstance; - private DumpCacheManager dumpCacheManager; + private static final InstanceIdentifier NAT_CONFIG_ID = + InstanceIdentifier.create(NatInstances.class) + .child(NatInstance.class, new NatInstanceKey(NatInstanceCustomizer.DEFAULT_VRF_ID)) + .child(NatCurrentConfig.class); + + private static final InstanceIdentifier NAT_DEFAULT_POOL_WILDCARDED_ID = + NAT_CONFIG_ID.child(ExternalIpAddressPool.class); + + private static final InstanceIdentifier 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 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() - .withExecutor(executor) - .acceptOnly(SnatAddressDetailsReplyDump.class) - .build(); + protected ReaderCustomizer initCustomizer() { + return new ExternalIpPoolCustomizer(jvppSnat); } - @Override - protected ReaderCustomizer 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 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 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 allIds = getCustomizer().getAllIds(externalPoolIdDefaultNatInstance, ctx); + final List 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 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 -- cgit 1.2.3-korg