</dependency>
<dependency>
<groupId>io.fd.vpp</groupId>
- <artifactId>jvpp-snat</artifactId>
+ <artifactId>jvpp-nat</artifactId>
<version>${jvpp.version}</version>
</dependency>
<dependency>
import io.fd.vpp.jvpp.ioamexport.JVppIoamexport;
import io.fd.vpp.jvpp.ioampot.JVppIoampot;
import io.fd.vpp.jvpp.ioamtrace.JVppIoamtrace;
-import io.fd.vpp.jvpp.snat.JVppSnat;
+import io.fd.vpp.jvpp.nat.JVppNat;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Scanner;
final Class[] apis = new Class[] {
JVppCore.class,
JVppAcl.class,
- JVppSnat.class,
+ JVppNat.class,
JVppIoamtrace.class,
JVppIoamexport.class,
JVppIoampot.class
-= SNAT
+= NAT
-Support fot VPP's SNAT plugin:
-https://docs.fd.io/vpp/17.07/plugins_snat-plugin_snat.html
+Support for VPP's NAT plugin:
+https://wiki.fd.io/view/VPP/NAT
== Supported features
}
revision "2017-08-01" {
- description "Added support for snat_interface_add_del_output_feature.";
+ description "Added support for nat_interface_add_del_output_feature.";
}
revision "2016-12-14" {
default false;
description
"Indicates whether NAT translation should be applied after routing.
- If true, snat_interface_add_del_output_feature message is used to enable NAT.
- By default snat_interface_add_del_feature is used.";
+ If true, nat_interface_add_del_output_feature message is used to enable NAT.
+ By default nat_interface_add_del_feature is used.";
reference
- "https://git.fd.io/vpp/tree/src/plugins/snat/snat.api";
+ "https://git.fd.io/vpp/tree/src/plugins/nat/nat.api";
}
leaf nat44-support {
description
"Indicates whether the pool is designated to be used for nat44 or nat64.";
reference
- "https://git.fd.io/vpp/tree/src/plugins/snat/snat.api";
+ "https://git.fd.io/vpp/tree/src/plugins/nat/nat.api";
}
}
= nat2vpp
-Uses jvpp-snat to work with VPP's SNAT plugin.
\ No newline at end of file
+Uses jvpp-nat to work with VPP's NAT plugin.
\ No newline at end of file
</dependency>
<dependency>
<groupId>io.fd.vpp</groupId>
- <artifactId>jvpp-snat</artifactId>
+ <artifactId>jvpp-nat</artifactId>
<version>17.10-SNAPSHOT</version>
</dependency>
import com.google.inject.Provider;
import com.google.inject.Singleton;
import com.google.inject.multibindings.Multibinder;
-import io.fd.hc2vpp.nat.jvpp.JVppSnatProvider;
+import io.fd.hc2vpp.nat.jvpp.JVppNatProvider;
import io.fd.hc2vpp.nat.read.NatReaderFactory;
import io.fd.hc2vpp.nat.read.ifc.IfcNatReaderFactory;
import io.fd.hc2vpp.nat.read.ifc.SubIfcNatReaderFactory;
import io.fd.hc2vpp.nat.write.ifc.SubIfcNatWriterFactory;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.write.WriterFactory;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NatModule extends AbstractModule {
private static final Logger LOG = LoggerFactory.getLogger(NatModule.class);
- private final Class<? extends Provider<FutureJVppSnatFacade>> jvppSnatProviderClass;
+ private final Class<? extends Provider<FutureJVppNatFacade>> jvppNatProviderClass;
public NatModule() {
- this(JVppSnatProvider.class);
+ this(JVppNatProvider.class);
}
@VisibleForTesting
- protected NatModule(Class<? extends Provider<FutureJVppSnatFacade>> jvppSnatProvider) {
- this.jvppSnatProviderClass = jvppSnatProvider;
+ protected NatModule(Class<? extends Provider<FutureJVppNatFacade>> jvppNatProvider) {
+ this.jvppNatProviderClass = jvppNatProvider;
}
@Override
LOG.debug("Installing NAT module");
// Bind to Plugin's JVPP
- bind(FutureJVppSnatFacade.class).toProvider(jvppSnatProviderClass).in(Singleton.class);
+ bind(FutureJVppNatFacade.class).toProvider(jvppNatProviderClass).in(Singleton.class);
final Multibinder<ReaderFactory> readBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class);
readBinder.addBinding().to(IfcNatReaderFactory.class).in(Singleton.class);
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.data.init.ShutdownHandler;
import io.fd.vpp.jvpp.JVppRegistry;
-import io.fd.vpp.jvpp.snat.JVppSnatImpl;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.JVppNatImpl;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Provides future API for jvpp-nsh plugin. Must be a singleton due to shutdown hook usage. Registers shutdown hook to
* free plugin's resources on shutdown.
*/
-public final class JVppSnatProvider extends ProviderTrait<FutureJVppSnatFacade> {
+public final class JVppNatProvider extends ProviderTrait<FutureJVppNatFacade> {
- private static final Logger LOG = LoggerFactory.getLogger(JVppSnatProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(JVppNatProvider.class);
@Inject
private JVppRegistry registry;
private ShutdownHandler shutdownHandler;
@Override
- protected FutureJVppSnatFacade create() {
+ protected FutureJVppNatFacade create() {
try {
- final JVppSnatImpl jvppSnat = new JVppSnatImpl();
+ final JVppNatImpl jvppNat = new JVppNatImpl();
// Free jvpp-nsh plugin's resources on shutdown
- shutdownHandler.register("jvpp-snat", jvppSnat);
+ shutdownHandler.register("jvpp-nat", jvppNat);
- LOG.info("Successfully loaded jvpp-snat plugin");
- return new FutureJVppSnatFacade(registry, jvppSnat);
+ LOG.info("Successfully loaded jvpp-nat plugin");
+ return new FutureJVppNatFacade(registry, jvppNat);
} catch (IOException e) {
throw new IllegalStateException("Unable to open VPP management connection", e);
}
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.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;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddressDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddressDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddressDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64PoolAddrDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64PoolAddrDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64PoolAddrDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
private static final Logger LOG = LoggerFactory.getLogger(ExternalIpPoolCustomizer.class);
- private final DumpCacheManager<SnatAddressDetailsReplyDump, Void> nat44DumpMgr;
+ private final DumpCacheManager<Nat44AddressDetailsReplyDump, 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)
+ ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat) {
+ checkNotNull(jvppNat, "jvppNat should not be null");
+ this.nat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat44AddressDetailsReplyDump, Void>()
+ .withExecutor((id, params) -> getReplyForRead(jvppNat.nat44AddressDump(new Nat44AddressDump()).toCompletableFuture(), id))
+ .acceptOnly(Nat44AddressDetailsReplyDump.class)
.build();
this.nat64DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat64PoolAddrDetailsReplyDump, Void>()
- .withExecutor((id, params) -> getReplyForRead(jvppSnat.nat64PoolAddrDump(new Nat64PoolAddrDump()).toCompletableFuture(), id))
+ .withExecutor((id, params) -> getReplyForRead(jvppNat.nat64PoolAddrDump(new Nat64PoolAddrDump()).toCompletableFuture(), id))
.acceptOnly(Nat64PoolAddrDetailsReplyDump.class)
.build();
}
LOG.trace("Reading current attributes for external IP pool: {}", id);
final Long poolId = id.firstKeyOf(ExternalIpAddressPool.class).getPoolId();
- final List<SnatAddressDetails> nat44Details =
+ final List<Nat44AddressDetails> nat44Details =
nat44DumpMgr.getDump(id, ctx.getModificationCache(), null)
- .or(new SnatAddressDetailsReplyDump()).snatAddressDetails;
+ .or(new Nat44AddressDetailsReplyDump()).nat44AddressDetails;
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));
+ final Nat44AddressDetails detail = nat44Details.get(Math.toIntExact(poolId));
readPoolIp(builder, detail.ipAddress);
setPoolType(builder, NatPoolType.Nat44);
} else {
// this customizer also returns every single address as a 32 prefix and assigns an artificial key to them
long addressCount = nat44DumpMgr.getDump(id, ctx.getModificationCache(), null)
- .or(new SnatAddressDetailsReplyDump()).snatAddressDetails.stream()
+ .or(new Nat44AddressDetailsReplyDump()).nat44AddressDetails.stream()
.count();
// The ietf-nat model groups address pools for Nat44 and Nat64 under the same list,
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.Nat64BibDetails;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDump;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
private static final Logger LOG = LoggerFactory.getLogger(MappingEntryCustomizer.class);
- private final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> nat44DumpManager;
+ private final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager;
private final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager;
private final MappingEntryContext mappingEntryContext;
MappingEntryCustomizer(
- final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> nat44DumpManager,
+ final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager,
final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager,
final MappingEntryContext mappingEntryContext) {
this.nat44DumpManager = nat44DumpManager;
final int idx = id.firstKeyOf(MappingEntry.class).getIndex().intValue();
final int natInstanceId = id.firstKeyOf(NatInstance.class).getId().intValue();
- final List<SnatStaticMappingDetails> nat44Details =
+ final List<Nat44StaticMappingDetails> nat44Details =
nat44DumpManager.getDump(id, ctx.getModificationCache(), null)
- .or(new SnatStaticMappingDetailsReplyDump()).snatStaticMappingDetails;
- final Optional<SnatStaticMappingDetails> snat44StaticMappingDetails =
+ .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails;
+ final Optional<Nat44StaticMappingDetails> nat44StaticMappingDetails =
mappingEntryContext.findDetailsNat44(nat44Details, natInstanceId, idx, ctx.getMappingContext());
- if (snat44StaticMappingDetails.isPresent()) {
- readNat44Entry(builder, idx, snat44StaticMappingDetails.get());
+ if (nat44StaticMappingDetails.isPresent()) {
+ readNat44Entry(builder, idx, nat44StaticMappingDetails.get());
} else {
final List<Nat64BibDetails> nat64Details =
nat64DumpManager.getDump(id, ctx.getModificationCache(), null)
.or(new Nat64BibDetailsReplyDump()).nat64BibDetails;
- final Optional<Nat64BibDetails> snat64StaticMappingDetails =
+ final Optional<Nat64BibDetails> nat64StaticMappingDetails =
mappingEntryContext.findDetailsNat64(nat64Details, natInstanceId, idx, ctx.getMappingContext());
- if (snat64StaticMappingDetails.isPresent()) {
- readNat64Entry(builder, idx, snat64StaticMappingDetails.get());
+ if (nat64StaticMappingDetails.isPresent()) {
+ readNat64Entry(builder, idx, nat64StaticMappingDetails.get());
}
}
}
private void readNat44Entry(@Nonnull final MappingEntryBuilder builder,
- final int index, final SnatStaticMappingDetails detail) {
+ final int index, final Nat44StaticMappingDetails detail) {
builder.setIndex((long) index);
builder.setType(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.MappingEntry.Type.Static);
final List<MappingEntryKey> entryKeys =
nat44DumpManager.getDump(id, context.getModificationCache(), null)
- .or(new SnatStaticMappingDetailsReplyDump()).snatStaticMappingDetails.stream()
+ .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
.filter(detail -> natInstanceId == detail.vrfId)
.map(detail -> mappingEntryContext
.getStoredOrArtificialIndex(natInstanceId, detail, context.getMappingContext()))
}
static final class MappingEntryNat44DumpExecutor
- implements EntityDumpExecutor<SnatStaticMappingDetailsReplyDump, Void>, JvppReplyConsumer {
+ implements EntityDumpExecutor<Nat44StaticMappingDetailsReplyDump, Void>, JvppReplyConsumer {
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
- MappingEntryNat44DumpExecutor(final FutureJVppSnatFacade jvppSnat) {
- this.jvppSnat = jvppSnat;
+ MappingEntryNat44DumpExecutor(final FutureJVppNatFacade jvppNat) {
+ this.jvppNat = jvppNat;
}
@Nonnull
@Override
- public SnatStaticMappingDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final Void params)
+ public Nat44StaticMappingDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final Void params)
throws ReadFailedException {
- return getReplyForRead(jvppSnat.snatStaticMappingDump(new SnatStaticMappingDump()).toCompletableFuture(),
+ return getReplyForRead(jvppNat.nat44StaticMappingDump(new Nat44StaticMappingDump()).toCompletableFuture(),
identifier);
}
}
static final class MappingEntryNat64DumpExecutor
implements EntityDumpExecutor<Nat64BibDetailsReplyDump, Void>, JvppReplyConsumer {
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
- MappingEntryNat64DumpExecutor(final FutureJVppSnatFacade jvppSnat) {
- this.jvppSnat = jvppSnat;
+ MappingEntryNat64DumpExecutor(final FutureJVppNatFacade jvppNat) {
+ this.jvppNat = jvppNat;
}
@Nonnull
throws ReadFailedException {
final Nat64BibDump dump = new Nat64BibDump();
dump.proto = -1; // dump entries for all protocols
- return getReplyForRead(jvppSnat.nat64BibDump(dump).toCompletableFuture(), identifier);
+ return getReplyForRead(jvppNat.nat64BibDump(dump).toCompletableFuture(), identifier);
}
}
}
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetailsReplyDump;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
private static final Logger LOG = LoggerFactory.getLogger(NatInstanceCustomizer.class);
static final NatInstanceKey DEFAULT_VRF_ID = new NatInstanceKey(0L);
- private final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> nat44DumpManager;
+ private final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager;
private final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager;
NatInstanceCustomizer(
- final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> nat44DumpManager,
+ final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager,
final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager) {
this.nat44DumpManager = nat44DumpManager;
this.nat64DumpManager = nat64DumpManager;
// Find the nat instance IDs (vrf-ids) by listing all static mappings and their VRF assignment
final List<NatInstanceKey> vrfIds = Stream.concat(
nat44DumpManager.getDump(id, context.getModificationCache(), null)
- .or(new SnatStaticMappingDetailsReplyDump()).snatStaticMappingDetails.stream()
+ .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
.map(detail -> detail.vrfId),
nat64DumpManager.getDump(id, context.getModificationCache(), null)
.or(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream()
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.Nat64BibDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.NatState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.NatStateBuilder;
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 FutureJVppNatFacade jvppNat;
private final MappingEntryContext mappingEntryContext;
- private final DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> mapEntryNat44DumpMgr;
+ private final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> mapEntryNat44DumpMgr;
private final DumpCacheManager<Nat64BibDetailsReplyDump, Void> mapEntryNat64DumpMgr;
@Inject
- public NatReaderFactory(final FutureJVppSnatFacade jvppSnat,
+ public NatReaderFactory(final FutureJVppNatFacade jvppNat,
final MappingEntryContext mappingEntryContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.mappingEntryContext = mappingEntryContext;
this.mapEntryNat44DumpMgr =
- new DumpCacheManager.DumpCacheManagerBuilder<SnatStaticMappingDetailsReplyDump, Void>()
- .withExecutor(new MappingEntryCustomizer.MappingEntryNat44DumpExecutor(jvppSnat))
- .acceptOnly(SnatStaticMappingDetailsReplyDump.class)
+ new DumpCacheManager.DumpCacheManagerBuilder<Nat44StaticMappingDetailsReplyDump, Void>()
+ .withExecutor(new MappingEntryCustomizer.MappingEntryNat44DumpExecutor(jvppNat))
+ .acceptOnly(Nat44StaticMappingDetailsReplyDump.class)
.build();
this.mapEntryNat64DumpMgr =
new DumpCacheManager.DumpCacheManagerBuilder<Nat64BibDetailsReplyDump, Void>()
- .withExecutor(new MappingEntryCustomizer.MappingEntryNat64DumpExecutor(jvppSnat))
+ .withExecutor(new MappingEntryCustomizer.MappingEntryNat64DumpExecutor(jvppNat))
.acceptOnly(Nat64BibDetailsReplyDump.class)
.build();
}
registry.addStructuralReader(CURRENT_CONFIG, NatCurrentConfigBuilder.class);
registry.add(new GenericInitListReader<>(CURRENT_CONFIG.child(ExternalIpAddressPool.class),
- new ExternalIpPoolCustomizer(jvppSnat)));
+ new ExternalIpPoolCustomizer(jvppNat)));
}
}
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.Nat64InterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.Nat64InterfaceDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDump;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64InterfaceDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yangtools.concepts.Builder;
abstract class AbstractInterfaceNatCustomizer<C extends DataObject, B extends Builder<C>>
implements InitializingReaderCustomizer<C, B>, JvppReplyConsumer {
- private final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> preRoutingNat44DumpMgr;
+ private final DumpCacheManager<Nat44InterfaceDetailsReplyDump, Void> preRoutingNat44DumpMgr;
private final DumpCacheManager<Nat64InterfaceDetailsReplyDump, Void> preRoutingNat64DumpMgr;
- private final DumpCacheManager<SnatInterfaceOutputFeatureDetailsReplyDump, Void> postRoutingNat44DumpMgr;
+ private final DumpCacheManager<Nat44InterfaceOutputFeatureDetailsReplyDump, Void> postRoutingNat44DumpMgr;
private final NamingContext ifcContext;
private final VppAttributesBuilder vppAttributesBuilder;
- AbstractInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ AbstractInterfaceNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext,
@Nonnull final VppAttributesBuilder vppAttributesBuilder) {
- requireNonNull(jvppSnat, "jvppSnat should not be null");
+ requireNonNull(jvppNat, "jvppNat should not be null");
this.ifcContext = requireNonNull(ifcContext, "ifcContext should not be null");
this.vppAttributesBuilder = requireNonNull(vppAttributesBuilder, "ifcContext should not be null");
this.preRoutingNat44DumpMgr =
- new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
+ new DumpCacheManager.DumpCacheManagerBuilder<Nat44InterfaceDetailsReplyDump, Void>()
.withExecutor((id, params) -> getReplyForRead(
- jvppSnat.snatInterfaceDump(new SnatInterfaceDump()).toCompletableFuture(), id))
- .acceptOnly(SnatInterfaceDetailsReplyDump.class)
+ jvppNat.nat44InterfaceDump(new Nat44InterfaceDump()).toCompletableFuture(), id))
+ .acceptOnly(Nat44InterfaceDetailsReplyDump.class)
.build();
this.preRoutingNat64DumpMgr =
new DumpCacheManager.DumpCacheManagerBuilder<Nat64InterfaceDetailsReplyDump, Void>()
.withExecutor((id, params) -> getReplyForRead(
- jvppSnat.nat64InterfaceDump(new Nat64InterfaceDump()).toCompletableFuture(), id))
+ jvppNat.nat64InterfaceDump(new Nat64InterfaceDump()).toCompletableFuture(), id))
.acceptOnly(Nat64InterfaceDetailsReplyDump.class)
.build();
this.postRoutingNat44DumpMgr =
- new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceOutputFeatureDetailsReplyDump, Void>()
+ new DumpCacheManager.DumpCacheManagerBuilder<Nat44InterfaceOutputFeatureDetailsReplyDump, Void>()
.withExecutor((id, params) -> getReplyForRead(
- jvppSnat.snatInterfaceOutputFeatureDump(new SnatInterfaceOutputFeatureDump())
+ jvppNat.nat44InterfaceOutputFeatureDump(new Nat44InterfaceOutputFeatureDump())
.toCompletableFuture(), id))
- .acceptOnly(SnatInterfaceOutputFeatureDetailsReplyDump.class)
+ .acceptOnly(Nat44InterfaceOutputFeatureDetailsReplyDump.class)
.build();
}
private void readPreRoutingNat44(final InstanceIdentifier<C> id, final int index, final B builder,
final ReadContext ctx) throws ReadFailedException {
- final Optional<SnatInterfaceDetailsReplyDump> dump =
+ final Optional<Nat44InterfaceDetailsReplyDump> dump =
preRoutingNat44DumpMgr.getDump(id, ctx.getModificationCache(), null);
- dump.or(new SnatInterfaceDetailsReplyDump()).snatInterfaceDetails.stream()
- .filter(snatIfcDetail -> snatIfcDetail.swIfIndex == index)
- .filter(snatIfcDetail -> isExpectedNatType(snatIfcDetail.isInside))
+ dump.or(new Nat44InterfaceDetailsReplyDump()).nat44InterfaceDetails.stream()
+ .filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
+ .filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
.findAny()
- .ifPresent(snatIfcDetail -> vppAttributesBuilder.enableNat44(builder));
+ .ifPresent(natIfcDetail -> vppAttributesBuilder.enableNat44(builder));
// do not modify builder is feature is absent (inbound/outbound are presence containers)
}
preRoutingNat64DumpMgr.getDump(id, ctx.getModificationCache(), null);
dump.or(new Nat64InterfaceDetailsReplyDump()).nat64InterfaceDetails.stream()
- .filter(snatIfcDetail -> snatIfcDetail.swIfIndex == index)
- .filter(snatIfcDetail -> isExpectedNatType(snatIfcDetail.isInside))
+ .filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
+ .filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
.findAny()
- .ifPresent(snatIfcDetail -> vppAttributesBuilder.enableNat64(builder));
+ .ifPresent(natIfcDetail -> vppAttributesBuilder.enableNat64(builder));
// do not modify builder is feature is absent (inbound/outbound are presence containers)
}
private void readPostRoutingNat44(final InstanceIdentifier<C> id, final int index, final B builder,
final ReadContext ctx) throws ReadFailedException {
- final Optional<SnatInterfaceOutputFeatureDetailsReplyDump> dump =
+ final Optional<Nat44InterfaceOutputFeatureDetailsReplyDump> dump =
postRoutingNat44DumpMgr.getDump(id, ctx.getModificationCache(), null);
- dump.or(new SnatInterfaceOutputFeatureDetailsReplyDump()).snatInterfaceOutputFeatureDetails
+ dump.or(new Nat44InterfaceOutputFeatureDetailsReplyDump()).nat44InterfaceOutputFeatureDetails
.stream()
- .filter(snatIfcDetail -> snatIfcDetail.swIfIndex == index)
- .filter(snatIfcDetail -> isExpectedNatType(snatIfcDetail.isInside))
+ .filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
+ .filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
.findAny()
- .ifPresent(snatIfcDetail -> vppAttributesBuilder.enablePostRouting(builder));
+ .ifPresent(natIfcDetail -> vppAttributesBuilder.enablePostRouting(builder));
// do not modify builder is feature is absent (inbound/outbound are presence containers)
}
import static com.google.common.base.Preconditions.checkNotNull;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces.state._interface.sub.interfaces.SubInterface;
abstract class AbstractSubInterfaceNatCustomizer<C extends DataObject, B extends Builder<C>>
extends AbstractInterfaceNatCustomizer<C, B> {
- AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext,
@Nonnull final VppAttributesBuilder vppAttributesBuilder) {
- super(jvppSnat, ifcContext, vppAttributesBuilder);
+ super(jvppNat, ifcContext, vppAttributesBuilder);
}
@Override
import io.fd.honeycomb.translate.impl.read.GenericInitReader;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
IFC_ID.augmentation(NatInterfaceStateAugmentation.class);
private static final InstanceIdentifier<Nat> NAT_AUG_CONTAINER_ID = NAT_AUG_ID.child(Nat.class);
private final NamingContext ifcContext;
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
@Inject
- public IfcNatReaderFactory(final FutureJVppSnatFacade jvppSnat,
+ public IfcNatReaderFactory(final FutureJVppNatFacade jvppNat,
@Named("interface-context") final NamingContext ifcContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.ifcContext = ifcContext;
}
registry.addStructuralReader(NAT_AUG_CONTAINER_ID, NatBuilder.class);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Inbound.class),
- new InterfaceInboundNatCustomizer(jvppSnat, ifcContext)), IFC_ID);
+ new InterfaceInboundNatCustomizer(jvppNat, ifcContext)), IFC_ID);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Outbound.class),
- new InterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), IFC_ID);
+ new InterfaceOutboundNatCustomizer(jvppNat, ifcContext)), IFC_ID);
}
}
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final Logger LOG = LoggerFactory.getLogger(InterfaceInboundNatCustomizer.class);
- InterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ InterfaceInboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext, new InboundAttributesBuilder());
+ super(jvppNat, ifcContext, new InboundAttributesBuilder());
}
@Override
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final Logger LOG = LoggerFactory.getLogger(InterfaceOutboundNatCustomizer.class);
- InterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ InterfaceOutboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext, new OutboundAttributesReader());
+ super(jvppNat, ifcContext, new OutboundAttributesReader());
}
@Override
import io.fd.honeycomb.translate.impl.read.GenericInitReader;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
private static final InstanceIdentifier<Nat> NAT_AUG_CONTAINER_ID = NAT_SUB_AUG_ID.child(Nat.class);
private final NamingContext ifcContext;
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
@Inject
- public SubIfcNatReaderFactory(final FutureJVppSnatFacade jvppSnat,
+ public SubIfcNatReaderFactory(final FutureJVppNatFacade jvppNat,
@Named("interface-context") final NamingContext ifcContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.ifcContext = ifcContext;
}
registry.addStructuralReader(NAT_AUG_CONTAINER_ID, NatBuilder.class);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Inbound.class),
- new SubInterfaceInboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceInboundNatCustomizer(jvppNat, ifcContext)), SUB_IFC_ID);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Outbound.class),
- new SubInterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceOutboundNatCustomizer(jvppNat, ifcContext)), SUB_IFC_ID);
}
}
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceInboundNatCustomizer.class);
- SubInterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ SubInterfaceInboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext, new InboundAttributesBuilder());
+ super(jvppNat, ifcContext, new InboundAttributesBuilder());
}
@Override
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.Initialized;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceOutboundNatCustomizer.class);
- SubInterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ SubInterfaceOutboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext, new OutboundAttributesReader());
+ super(jvppNat, ifcContext, new OutboundAttributesReader());
}
@Override
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
import io.fd.honeycomb.translate.MappingContext;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetails;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
return new MappingEntryKey(new IpAddress(entry.getExternalSrcAddress()), entry.getInternalSrcAddress());
}
- private MappingEntryKey entryToKey(final SnatStaticMappingDetails entry) {
+ private MappingEntryKey entryToKey(final Nat44StaticMappingDetails entry) {
// Only IPv4
return new MappingEntryKey(
new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(entry.externalIpAddress))),
new IpAddress(new Ipv6Address(arrayToIpv6AddressNoZone(entry.iAddr))));
}
- private boolean equalEntries(final SnatStaticMappingDetails detail, final MappingEntry ctxMappingEntry) {
+ private boolean equalEntries(final Nat44StaticMappingDetails detail, final MappingEntry ctxMappingEntry) {
final IpAddress internalAddrFromDetails =
new IpAddress(new Ipv4Address(arrayToIpv4AddressNoZone(detail.localIpAddress)));
// Only IPv4
.build();
}
- private MappingEntry toCtxMapEntry(@Nonnull final SnatStaticMappingDetails details, final long entryId) {
+ private MappingEntry toCtxMapEntry(@Nonnull final Nat44StaticMappingDetails details, final long entryId) {
return new MappingEntryBuilder()
.setKey(entryToKey(details))
.setIndex(entryId)
/**
* Find specific details in provided collection identified with provided index.
*/
- public synchronized java.util.Optional<SnatStaticMappingDetails> findDetailsNat44(@Nonnull final List<SnatStaticMappingDetails> details,
- final long natInstanceId, final long idx,
- @Nonnull final MappingContext mappingContext) {
+ public synchronized java.util.Optional<Nat44StaticMappingDetails> findDetailsNat44(@Nonnull final List<Nat44StaticMappingDetails> details,
+ final long natInstanceId, final long idx,
+ @Nonnull final MappingContext mappingContext) {
// Find mapping entry for Index
final MappingEntry ctxMappingEntry = mappingContext.read(getTableId(natInstanceId))
.transform(MappingTable::getMappingEntry)
* Get index for a mapping entry details or create an artificial one.
*/
public synchronized long getStoredOrArtificialIndex(final Long natInstanceId,
- @Nonnull final SnatStaticMappingDetails details,
+ @Nonnull final Nat44StaticMappingDetails details,
@Nonnull final MappingContext mappingContext) {
return mappingContext.read(getId(natInstanceId, entryToKey(details)))
.transform(MappingEntry::getIndex)
.transform(MappingEntry::getIndex);
}
- private long getArtificialId(final SnatStaticMappingDetails details, final Long natInstanceId,
+ private long getArtificialId(final Nat44StaticMappingDetails details, final Long natInstanceId,
final MappingContext mappingContext) {
LOG.trace("Assigning artificial ID for {}", details);
final long artificialIdx = findFreeIndex(natInstanceId, mappingContext);
import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelPoolAddrRange;
-import io.fd.vpp.jvpp.snat.dto.SnatAddAddressRange;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelAddressRange;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelPoolAddrRange;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.config.nat.instances.NatInstance;
private static final Logger LOG = LoggerFactory.getLogger(ExternalIpPoolCustomizer.class);
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
- ExternalIpPoolCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat) {
- this.jvppSnat = jvppSnat;
+ ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat) {
+ this.jvppNat = jvppNat;
}
@Override
}
if (isNat64) {
final Nat64AddDelPoolAddrRange request = getNat64Request(addressPool.getExternalIpPool(), isAdd);
- getReplyForWrite(jvppSnat.nat64AddDelPoolAddrRange(request).toCompletableFuture(), id);
+ getReplyForWrite(jvppNat.nat64AddDelPoolAddrRange(request).toCompletableFuture(), id);
} else {
- final SnatAddAddressRange request = getNat44Request(addressPool.getExternalIpPool(), isAdd);
- getReplyForWrite(jvppSnat.snatAddAddressRange(request).toCompletableFuture(), id);
+ final Nat44AddDelAddressRange request = getNat44Request(addressPool.getExternalIpPool(), isAdd);
+ getReplyForWrite(jvppNat.nat44AddDelAddressRange(request).toCompletableFuture(), id);
}
}
- private SnatAddAddressRange getNat44Request(final Ipv4Prefix externalIpPool, boolean isAdd) {
- final SnatAddAddressRange request = new SnatAddAddressRange();
+ private Nat44AddDelAddressRange getNat44Request(final Ipv4Prefix externalIpPool, boolean isAdd) {
+ final Nat44AddDelAddressRange request = new Nat44AddDelAddressRange();
final Ipv4AddressRange range = Ipv4AddressRange.fromPrefix(externalIpPool);
LOG.trace("Handling NAT44 address range: {}", range);
- request.isIp4 = 1;
request.isAdd = booleanToByte(isAdd);
request.firstIpAddress = ipv4AddressNoZoneToArray(range.getStart());
request.lastIpAddress = ipv4AddressNoZoneToArray(range.getEnd());
import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelStaticBib;
-import io.fd.vpp.jvpp.snat.dto.SnatAddStaticMapping;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelStaticMapping;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelStaticBib;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
private static final Logger LOG = LoggerFactory.getLogger(MappingEntryCustomizer.class);
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
private final MappingEntryContext mappingEntryContext;
- MappingEntryCustomizer(final FutureJVppSnatFacade jvppSnat, final MappingEntryContext mappingEntryContext) {
- this.jvppSnat = jvppSnat;
+ MappingEntryCustomizer(final FutureJVppNatFacade jvppNat, final MappingEntryContext mappingEntryContext) {
+ this.jvppNat = jvppNat;
this.mappingEntryContext = mappingEntryContext;
}
final Ipv4Address internalV4SrcAddress = internalSrcAddress.getIpv4Address();
final Ipv6Address internalV6SrcAddress = internalSrcAddress.getIpv6Address();
if (internalV4SrcAddress != null) {
- final SnatAddStaticMapping request = getNat44Request(id, entry, natInstanceId, isAdd);
- getReplyForWrite(jvppSnat.snatAddStaticMapping(request).toCompletableFuture(), id);
+ final Nat44AddDelStaticMapping request = getNat44Request(id, entry, natInstanceId, isAdd);
+ getReplyForWrite(jvppNat.nat44AddDelStaticMapping(request).toCompletableFuture(), id);
} else {
checkState(internalV6SrcAddress != null,
"internalSrcAddress.getIpv6Address() should not return null if v4 address is not given");
final Nat64AddDelStaticBib request = getNat64Request(id, entry, natInstanceId, isAdd);
- getReplyForWrite(jvppSnat.nat64AddDelStaticBib(request).toCompletableFuture(), id);
+ getReplyForWrite(jvppNat.nat64AddDelStaticBib(request).toCompletableFuture(), id);
}
}
LOG.trace("Mapping entry: {} for nat-instance(vrf): {} deleted successfully", natInstanceId, id);
}
- private SnatAddStaticMapping getNat44Request(final InstanceIdentifier<MappingEntry> id,
+ private Nat44AddDelStaticMapping getNat44Request(final InstanceIdentifier<MappingEntry> id,
final MappingEntry mappingEntry,
final Long natInstanceId,
final boolean isAdd)
throws WriteFailedException.CreateFailedException {
- final SnatAddStaticMapping request = new SnatAddStaticMapping();
+ final Nat44AddDelStaticMapping request = new Nat44AddDelStaticMapping();
request.isAdd = booleanToByte(isAdd);
- request.isIp4 = 1;
// VPP uses int, model long
request.vrfId = natInstanceId.intValue();
import io.fd.honeycomb.translate.impl.write.GenericListWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.NatConfig;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.mapping.entry.ExternalSrcPort;
private static final InstanceIdentifier<MappingEntry> MAP_ENTRY_ID =
NAT_INSTANCE_ID.child(MappingTable.class).child(MappingEntry.class);
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
private final MappingEntryContext mappingEntryContext;
@Inject
- public NatWriterFactory(final FutureJVppSnatFacade jvppSnat,
+ public NatWriterFactory(final FutureJVppNatFacade jvppNat,
final MappingEntryContext mappingEntryContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.mappingEntryContext = mappingEntryContext;
}
// Mapping-entry
registry.subtreeAdd(Sets.newHashSet(InstanceIdentifier.create(MappingEntry.class).child(ExternalSrcPort.class),
InstanceIdentifier.create(MappingEntry.class).child(InternalSrcPort.class)),
- new GenericListWriter<>(MAP_ENTRY_ID, new MappingEntryCustomizer(jvppSnat, mappingEntryContext)));
+ new GenericListWriter<>(MAP_ENTRY_ID, new MappingEntryCustomizer(jvppNat, mappingEntryContext)));
// External address pool has to be executed before mapping entry. Because adding mapping entries requires to
// already have an IP range predefined ... in some cases
Sets.newHashSet(InstanceIdentifier.create(ExternalIpAddressPool.class)
.augmentation(ExternalIpAddressPoolConfigAugmentation.class)),
new GenericListWriter<>(NAT_INSTANCE_ID.child(ExternalIpAddressPool.class),
- new ExternalIpPoolCustomizer(jvppSnat)),
+ new ExternalIpPoolCustomizer(jvppNat)),
MAP_ENTRY_ID);
}
}
import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelInterface;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelFeature;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelOutputFeature;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelFeature;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelOutputFeature;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelInterface;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816.InterfaceNatVppFeatureAttributes;
abstract class AbstractInterfaceNatCustomizer<D extends InterfaceNatVppFeatureAttributes & DataObject>
implements ByteDataTranslator, JvppReplyConsumer, WriterCustomizer<D> {
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
private final NamingContext ifcContext;
- AbstractInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ AbstractInterfaceNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.ifcContext = ifcContext;
}
final boolean enable)
throws WriteFailedException {
checkArgument(!isNat64Supported(natAttributes), "Post routing Nat64 is not supported by VPP");
- final SnatInterfaceAddDelOutputFeature request = new SnatInterfaceAddDelOutputFeature();
+ final Nat44InterfaceAddDelOutputFeature request = new Nat44InterfaceAddDelOutputFeature();
request.isAdd = booleanToByte(enable);
request.isInside = getType().isInside;
request.swIfIndex = ifcIndex;
- getReplyForWrite(jvppSnat.snatInterfaceAddDelOutputFeature(request).toCompletableFuture(), id);
+ getReplyForWrite(jvppNat.nat44InterfaceAddDelOutputFeature(request).toCompletableFuture(), id);
}
private void preRoutingNat(@Nonnull final InstanceIdentifier<D> id, final D natAttributes, final int ifcIndex,
private void preRoutingNat44(@Nonnull final InstanceIdentifier<D> id, final int ifcIndex, final boolean enable)
throws WriteFailedException {
- final SnatInterfaceAddDelFeature request = new SnatInterfaceAddDelFeature();
+ final Nat44InterfaceAddDelFeature request = new Nat44InterfaceAddDelFeature();
request.isAdd = booleanToByte(enable);
request.isInside = getType().isInside;
request.swIfIndex = ifcIndex;
- getReplyForWrite(jvppSnat.snatInterfaceAddDelFeature(request).toCompletableFuture(), id);
+ getReplyForWrite(jvppNat.nat44InterfaceAddDelFeature(request).toCompletableFuture(), id);
}
private void preRoutingNat64(@Nonnull final InstanceIdentifier<D> id, final int ifcIndex, final boolean enable)
request.isAdd = booleanToByte(enable);
request.isInside = getType().isInside;
request.swIfIndex = ifcIndex;
- getReplyForWrite(jvppSnat.nat64AddDelInterface(request).toCompletableFuture(), id);
+ getReplyForWrite(jvppNat.nat64AddDelInterface(request).toCompletableFuture(), id);
}
enum NatType {
import static com.google.common.base.Preconditions.checkNotNull;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816.InterfaceNatVppFeatureAttributes;
abstract class AbstractSubInterfaceNatCustomizer<D extends InterfaceNatVppFeatureAttributes & DataObject>
extends AbstractInterfaceNatCustomizer<D> {
- AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext);
+ super(jvppNat, ifcContext);
}
@Override
import io.fd.honeycomb.translate.impl.write.GenericWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final InstanceIdentifier<Nat> NAT_AUG_ID =
IFC_ID.augmentation(NatInterfaceAugmentation.class).child(Nat.class);
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
private final NamingContext ifcContext;
@Inject
- public IfcNatWriterFactory(final FutureJVppSnatFacade jvppSnat,
+ public IfcNatWriterFactory(final FutureJVppNatFacade jvppNat,
@Named("interface-context") final NamingContext ifcContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.ifcContext = ifcContext;
}
@Override
public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
registry.addAfter(new GenericWriter<>(NAT_AUG_ID.child(Inbound.class),
- new InterfaceInboundNatCustomizer(jvppSnat, ifcContext)), IFC_ID);
+ new InterfaceInboundNatCustomizer(jvppNat, ifcContext)), IFC_ID);
registry.addAfter(new GenericWriter<>(NAT_AUG_ID.child(Outbound.class),
- new InterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), IFC_ID);
+ new InterfaceOutboundNatCustomizer(jvppNat, ifcContext)), IFC_ID);
}
}
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816._interface.nat.attributes.nat.Inbound;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(InterfaceInboundNatCustomizer.class);
- InterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ InterfaceInboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext);
+ super(jvppNat, ifcContext);
}
@Override
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816._interface.nat.attributes.nat.Outbound;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(InterfaceOutboundNatCustomizer.class);
- InterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ InterfaceOutboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext);
+ super(jvppNat, ifcContext);
}
@Override
import io.fd.honeycomb.translate.impl.write.GenericWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static final InstanceIdentifier<Nat> NAT_AUG_ID =
SUB_IFC_ID.augmentation(NatSubinterfaceAugmentation.class).child(Nat.class);
- private final FutureJVppSnatFacade jvppSnat;
+ private final FutureJVppNatFacade jvppNat;
private final NamingContext ifcContext;
@Inject
- public SubIfcNatWriterFactory(final FutureJVppSnatFacade jvppSnat,
+ public SubIfcNatWriterFactory(final FutureJVppNatFacade jvppNat,
@Named("interface-context") final NamingContext ifcContext) {
- this.jvppSnat = jvppSnat;
+ this.jvppNat = jvppNat;
this.ifcContext = ifcContext;
}
@Override
public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
registry.addAfter(new GenericWriter<>(NAT_AUG_ID.child(Inbound.class),
- new SubInterfaceInboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceInboundNatCustomizer(jvppNat, ifcContext)), SUB_IFC_ID);
registry.addAfter(new GenericWriter<>(NAT_AUG_ID.child(Outbound.class),
- new SubInterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceOutboundNatCustomizer(jvppNat, ifcContext)), SUB_IFC_ID);
}
}
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816._interface.nat.attributes.nat.Inbound;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceInboundNatCustomizer.class);
- SubInterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ SubInterfaceInboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext);
+ super(jvppNat, ifcContext);
}
@Override
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816._interface.nat.attributes.nat.Outbound;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceOutboundNatCustomizer.class);
- SubInterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ SubInterfaceOutboundNatCustomizer(@Nonnull final FutureJVppNatFacade jvppNat,
@Nonnull final NamingContext ifcContext) {
- super(jvppSnat, ifcContext);
+ super(jvppNat, ifcContext);
}
@Override
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
import io.fd.honeycomb.translate.util.YangDAG;
import io.fd.honeycomb.translate.write.WriterFactory;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.util.HashSet;
import java.util.Set;
import org.junit.Before;
registry.add(new GenericListReader<>(
InstanceIdentifier.create(InterfacesState.class).child(Interface.class),
mock(ListReaderCustomizer.class)));
- }), new NatModule(MockJVppSnatProvider.class), BoundFieldModule.of(this)).injectMembers(this);
+ }), new NatModule(MockJVppNatProvider.class), BoundFieldModule.of(this)).injectMembers(this);
}
@Test
assertNotNull(registryBuilder.build());
}
- private static final class MockJVppSnatProvider implements Provider<FutureJVppSnatFacade> {
+ private static final class MockJVppNatProvider implements Provider<FutureJVppNatFacade> {
@Override
- public FutureJVppSnatFacade get() {
- return mock(FutureJVppSnatFacade.class);
+ public FutureJVppNatFacade get() {
+ return mock(FutureJVppNatFacade.class);
}
}
}
\ No newline at end of file
import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
-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 io.fd.vpp.jvpp.nat.dto.Nat44AddressDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddressDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64PoolAddrDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64PoolAddrDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.util.Arrays;
import java.util.List;
import java.util.stream.LongStream;
.child(NatCurrentConfig.class).child(ExternalIpAddressPool.class);
@Mock
- private FutureJVppSnatFacade jvppSnat;
+ private FutureJVppNatFacade jvppNat;
public ExternalIpPoolCustomizerTest() {
super(ExternalIpAddressPool.class, NatCurrentConfigBuilder.class);
@Override
protected ReaderCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolBuilder> initCustomizer() {
- return new ExternalIpPoolCustomizer(jvppSnat);
+ return new ExternalIpPoolCustomizer(jvppNat);
}
@Test
public void testReadAttributesNat44() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
final long poolId = 2;
final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx);
@Test
public void testReadAttributesNat64() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
final long poolId = 2;
final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
@Test
public void testReadAttributes() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
final long poolId = 5;
final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder();
@Test
public void testGetAllNat44() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
assertThat(allIds, hasItems(
@Test
public void testGetAllNat64() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
assertThat(allIds, hasItems(
@Test
public void testGetAll() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty()));
final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx);
assertThat(allIds, hasItems(
@Test
public void testGetAllNoDump() throws Exception {
- when(jvppSnat.snatAddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
- when(jvppSnat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
+ when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty()));
+ when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty()));
assertThat(getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx), empty());
}
return NAT_CONFIG_ID.child(ExternalIpAddressPool.class, new ExternalIpAddressPoolKey(id));
}
- private static SnatAddressDetailsReplyDump dumpReplyNat44Empty() {
- return new SnatAddressDetailsReplyDump();
+ private static Nat44AddressDetailsReplyDump dumpReplyNat44Empty() {
+ return new Nat44AddressDetailsReplyDump();
}
- private static SnatAddressDetailsReplyDump dumpReplyNat44NonEmpty() {
- SnatAddressDetailsReplyDump replyDump = dumpReplyNat44Empty();
+ private static Nat44AddressDetailsReplyDump dumpReplyNat44NonEmpty() {
+ Nat44AddressDetailsReplyDump replyDump = dumpReplyNat44Empty();
- SnatAddressDetails detailsOne = new SnatAddressDetails();
+ Nat44AddressDetails detailsOne = new Nat44AddressDetails();
detailsOne.ipAddress = new byte[]{-64, -88, 44, 1};
- detailsOne.isIp4 = 1;
- SnatAddressDetails detailsTwo = new SnatAddressDetails();
+ Nat44AddressDetails detailsTwo = new Nat44AddressDetails();
detailsTwo.ipAddress = new byte[]{-64, -88, 44, 2};
- detailsTwo.isIp4 = 1;
- SnatAddressDetails detailsThree = new SnatAddressDetails();
+ Nat44AddressDetails detailsThree = new Nat44AddressDetails();
detailsThree.ipAddress = new byte[]{-64, -88, 44, 3};
- detailsThree.isIp4 = 1;
- replyDump.snatAddressDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
+ replyDump.nat44AddressDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
return replyDump;
}
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.Nat64BibDetails;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetailsReplyDump;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
private static final long NAT_MAPPING_ID = 2L;
private InstanceIdentifier<MappingEntry> mappingEntryId;
private InstanceIdentifier<MappingEntry> mappingEntryWildcarded;
- private DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> nat44DumpManager;
+ private DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager;
private DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager;
@Mock
private MappingEntryContext mappingContext;
@Mock
- private EntityDumpExecutor<SnatStaticMappingDetailsReplyDump, Void> nat44DumpExecutor;
+ private EntityDumpExecutor<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpExecutor;
@Mock
private EntityDumpExecutor<Nat64BibDetailsReplyDump, Void> nat64DumpExecutor;
.child(NatInstance.class, new NatInstanceKey(NatInstanceCustomizer.DEFAULT_VRF_ID))
.child(MappingTable.class)
.child(MappingEntry.class);
- nat44DumpManager = new DumpCacheManager.DumpCacheManagerBuilder<SnatStaticMappingDetailsReplyDump, Void>()
+ nat44DumpManager = new DumpCacheManager.DumpCacheManagerBuilder<Nat44StaticMappingDetailsReplyDump, Void>()
.withExecutor(nat44DumpExecutor)
- .acceptOnly(SnatStaticMappingDetailsReplyDump.class)
+ .acceptOnly(Nat44StaticMappingDetailsReplyDump.class)
.build();
nat64DumpManager = new DumpCacheManager.DumpCacheManagerBuilder<Nat64BibDetailsReplyDump, Void>()
.withExecutor(nat64DumpExecutor)
@Test
public void testReadNat44() throws Exception {
- final SnatStaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
+ final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat44);
final MappingEntryBuilder builder = new MappingEntryBuilder();
when(mappingContext
- .findDetailsNat44(dumpNat44.snatStaticMappingDetails, NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
+ .findDetailsNat44(dumpNat44.nat44StaticMappingDetails, NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
NAT_MAPPING_ID, ctx.getMappingContext()))
- .thenReturn(Optional.of(dumpNat44.snatStaticMappingDetails.get(2)));
+ .thenReturn(Optional.of(dumpNat44.nat44StaticMappingDetails.get(2)));
getCustomizer().readCurrentAttributes(mappingEntryId, builder, ctx);
assertEquals(NAT_MAPPING_ID, builder.getIndex().longValue());
@Test
public void testReadNat64() throws Exception {
- when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(new SnatStaticMappingDetailsReplyDump());
+ when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(new Nat44StaticMappingDetailsReplyDump());
final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty();
when(nat64DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat64);
final MappingEntryBuilder builder = new MappingEntryBuilder();
@Test
public void testReadAllNat44() throws Exception {
- final SnatStaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
+ final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat44);
when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(new Nat64BibDetailsReplyDump());
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L);
+ dumpNat44.nat44StaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L);
+ dumpNat44.nat44StaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L);
+ dumpNat44.nat44StaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L);
final List<MappingEntryKey> allIds = getCustomizer().getAllIds(mappingEntryWildcarded, ctx);
assertThat(allIds, hasItems(new MappingEntryKey(0L), new MappingEntryKey(2L)));
public void testReadAllNat64() throws Exception {
final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty();
when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null))
- .thenReturn(new SnatStaticMappingDetailsReplyDump());
+ .thenReturn(new Nat44StaticMappingDetailsReplyDump());
when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat64);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
dumpNat64.nat64BibDetails.get(0), ctx.getMappingContext())).thenReturn(0L);
@Test
public void testReadAll() throws Exception {
- final SnatStaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
+ final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty();
final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty();
when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null))
.thenReturn(dumpNat44);
when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat64);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L);
+ dumpNat44.nat44StaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L);
+ dumpNat44.nat44StaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
- dumpNat44.snatStaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L);
+ dumpNat44.nat44StaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
dumpNat64.nat64BibDetails.get(0), ctx.getMappingContext())).thenReturn(3L);
when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(),
return new MappingEntryCustomizer(nat44DumpManager, nat64DumpManager, mappingContext);
}
- private static SnatStaticMappingDetailsReplyDump dumpReplyNat44NonEmpty() {
- SnatStaticMappingDetailsReplyDump replyDump = new SnatStaticMappingDetailsReplyDump();
+ private static Nat44StaticMappingDetailsReplyDump dumpReplyNat44NonEmpty() {
+ Nat44StaticMappingDetailsReplyDump replyDump = new Nat44StaticMappingDetailsReplyDump();
- SnatStaticMappingDetails detailsOne = new SnatStaticMappingDetails();
- detailsOne.isIp4 = 1;
+ Nat44StaticMappingDetails detailsOne = new Nat44StaticMappingDetails();
detailsOne.addrOnly = 1;
detailsOne.localIpAddress = new byte[]{-64, -88, 2, 1};
detailsOne.localPort = 1234;
detailsOne.externalPort = 5874;
detailsOne.vrfId = NatInstanceCustomizer.DEFAULT_VRF_ID.getId().byteValue();
- SnatStaticMappingDetails detailsTwo = new SnatStaticMappingDetails();
- detailsTwo.isIp4 = 1;
+ Nat44StaticMappingDetails detailsTwo = new Nat44StaticMappingDetails();
detailsTwo.addrOnly = 1;
detailsTwo.localIpAddress = new byte[]{-64, -88, 2, 3};
detailsTwo.localPort = 1235;
detailsTwo.externalPort = 5874;
detailsTwo.vrfId = 2;
- SnatStaticMappingDetails detailsThree = new SnatStaticMappingDetails();
- detailsThree.isIp4 = 1;
+ Nat44StaticMappingDetails detailsThree = new Nat44StaticMappingDetails();
detailsThree.addrOnly = 0;
detailsThree.localIpAddress = new byte[]{-64, -88, 2, 2};
detailsThree.localPort = 1274;
detailsThree.externalPort = 6874;
detailsThree.vrfId = NatInstanceCustomizer.DEFAULT_VRF_ID.getId().byteValue();
- replyDump.snatStaticMappingDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
+ replyDump.nat44StaticMappingDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
return replyDump;
}
import io.fd.honeycomb.translate.read.ReadFailedException;
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.Nat64BibDetails;
-import io.fd.vpp.jvpp.snat.dto.Nat64BibDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat64BibDetailsReplyDump;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
public class NatInstanceCustomizerTest
extends InitializingListReaderCustomizerTest<NatInstance, NatInstanceKey, NatInstanceBuilder> {
@Mock
- private EntityDumpExecutor<SnatStaticMappingDetailsReplyDump, Void> nat44DumpExecutor;
+ private EntityDumpExecutor<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpExecutor;
@Mock
private EntityDumpExecutor<Nat64BibDetailsReplyDump, Void> nat64DumpExecutor;
private KeyedInstanceIdentifier<NatInstance, NatInstanceKey> natInstanceId;
private InstanceIdentifier<NatInstance> natInstanceWildcarded;
- private DumpCacheManager<SnatStaticMappingDetailsReplyDump, Void> mapEntryNat44DumpMgr;
+ private DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> mapEntryNat44DumpMgr;
private DumpCacheManager<Nat64BibDetailsReplyDump, Void> mapEntryNat64DumpMgr;
public NatInstanceCustomizerTest() {
.child(NatInstance.class, new NatInstanceKey(NatInstanceCustomizer.DEFAULT_VRF_ID));
natInstanceWildcarded = InstanceIdentifier.create(NatInstances.class)
.child(NatInstance.class);
- mapEntryNat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatStaticMappingDetailsReplyDump, Void>()
+ mapEntryNat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat44StaticMappingDetailsReplyDump, Void>()
.withExecutor(nat44DumpExecutor)
- .acceptOnly(SnatStaticMappingDetailsReplyDump.class)
+ .acceptOnly(Nat44StaticMappingDetailsReplyDump.class)
.build();
mapEntryNat64DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat64BibDetailsReplyDump, Void>()
.withExecutor(nat64DumpExecutor)
new NatInstanceKey(5L), new NatInstanceKey(6L)));
}
- private static SnatStaticMappingDetailsReplyDump nat44NonEmptyDump() {
- SnatStaticMappingDetailsReplyDump replyDump = new SnatStaticMappingDetailsReplyDump();
- SnatStaticMappingDetails detailsOne = new SnatStaticMappingDetails();
+ private static Nat44StaticMappingDetailsReplyDump nat44NonEmptyDump() {
+ Nat44StaticMappingDetailsReplyDump replyDump = new Nat44StaticMappingDetailsReplyDump();
+ Nat44StaticMappingDetails detailsOne = new Nat44StaticMappingDetails();
detailsOne.vrfId = 1;
- SnatStaticMappingDetails detailsTwo = new SnatStaticMappingDetails();
+ Nat44StaticMappingDetails detailsTwo = new Nat44StaticMappingDetails();
detailsTwo.vrfId = 2;
- SnatStaticMappingDetails detailsThree = new SnatStaticMappingDetails();
+ Nat44StaticMappingDetails detailsThree = new Nat44StaticMappingDetails();
detailsThree.vrfId = 3;
- replyDump.snatStaticMappingDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
+ replyDump.nat44StaticMappingDetails = Arrays.asList(detailsOne, detailsTwo, detailsThree);
return replyDump;
}
import io.fd.honeycomb.translate.impl.read.GenericReader;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.vpp.jvpp.snat.dto.Nat64InterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
private static final String CTX_NAME = "ifc";
@Mock
- private FutureJVppSnatFacade jvppSnat;
+ private FutureJVppNatFacade jvppNat;
private NamingContext ifcContext = new NamingContext(CTX_NAME, CTX_NAME);
private InstanceIdentifier<Inbound> id;
protected void setUp() throws Exception {
id = getId(Inbound.class);
defineMapping(mappingContext, IFC_NAME, IFC_IDX, CTX_NAME);
- when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(new SnatInterfaceDetailsReplyDump()));
- when(jvppSnat.snatInterfaceOutputFeatureDump(any()))
- .thenReturn(future(new SnatInterfaceOutputFeatureDetailsReplyDump()));
- when(jvppSnat.nat64InterfaceDump(any()))
+ when(jvppNat.nat44InterfaceDump(any())).thenReturn(future(new Nat44InterfaceDetailsReplyDump()));
+ when(jvppNat.nat44InterfaceOutputFeatureDump(any()))
+ .thenReturn(future(new Nat44InterfaceOutputFeatureDetailsReplyDump()));
+ when(jvppNat.nat64InterfaceDump(any()))
.thenReturn(future(new Nat64InterfaceDetailsReplyDump()));
}
}
private void mockPostRoutingDump() {
- final SnatInterfaceOutputFeatureDetailsReplyDump details = new SnatInterfaceOutputFeatureDetailsReplyDump();
- final SnatInterfaceOutputFeatureDetails detail = new SnatInterfaceOutputFeatureDetails();
+ final Nat44InterfaceOutputFeatureDetailsReplyDump details = new Nat44InterfaceOutputFeatureDetailsReplyDump();
+ final Nat44InterfaceOutputFeatureDetails detail = new Nat44InterfaceOutputFeatureDetails();
detail.isInside = 1;
detail.swIfIndex = IFC_IDX;
- details.snatInterfaceOutputFeatureDetails = Lists.newArrayList(detail);
- when(jvppSnat.snatInterfaceOutputFeatureDump(any())).thenReturn(future(details));
+ details.nat44InterfaceOutputFeatureDetails = Lists.newArrayList(detail);
+ when(jvppNat.nat44InterfaceOutputFeatureDump(any())).thenReturn(future(details));
}
@Test
public void testPresencePreRouting() throws Exception {
- final SnatInterfaceDetailsReplyDump details = new SnatInterfaceDetailsReplyDump();
- final SnatInterfaceDetails detail = new SnatInterfaceDetails();
+ final Nat44InterfaceDetailsReplyDump details = new Nat44InterfaceDetailsReplyDump();
+ final Nat44InterfaceDetails detail = new Nat44InterfaceDetails();
detail.isInside = 1;
detail.swIfIndex = IFC_IDX;
- details.snatInterfaceDetails = Lists.newArrayList(detail);
- when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(details));
+ details.nat44InterfaceDetails = Lists.newArrayList(detail);
+ when(jvppNat.nat44InterfaceDump(any())).thenReturn(future(details));
assertTrue(getReader().read(id, ctx).isPresent());
}
@Override
protected ReaderCustomizer<Inbound, InboundBuilder> initCustomizer() {
- return new InterfaceInboundNatCustomizer(jvppSnat, ifcContext);
+ return new InterfaceInboundNatCustomizer(jvppNat, ifcContext);
}
}
\ No newline at end of file
import io.fd.honeycomb.translate.impl.read.GenericReader;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.vpp.jvpp.snat.dto.Nat64InterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceOutputFeatureDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceOutputFeatureDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.dto.Nat64InterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816._interface.nat.attributes.NatBuilder;
private static final String CTX_NAME = "ifc";
@Mock
- private FutureJVppSnatFacade jvppSnat;
+ private FutureJVppNatFacade jvppNat;
private NamingContext ifcContext = new NamingContext(CTX_NAME, CTX_NAME);
private InstanceIdentifier<Outbound> id;
protected void setUp() throws Exception {
id = getId(Outbound.class);
defineMapping(mappingContext, IFC_NAME, IFC_IDX, CTX_NAME);
- when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(new SnatInterfaceDetailsReplyDump()));
- when(jvppSnat.snatInterfaceOutputFeatureDump(any()))
- .thenReturn(future(new SnatInterfaceOutputFeatureDetailsReplyDump()));
- when(jvppSnat.nat64InterfaceDump(any()))
+ when(jvppNat.nat44InterfaceDump(any())).thenReturn(future(new Nat44InterfaceDetailsReplyDump()));
+ when(jvppNat.nat44InterfaceOutputFeatureDump(any()))
+ .thenReturn(future(new Nat44InterfaceOutputFeatureDetailsReplyDump()));
+ when(jvppNat.nat64InterfaceDump(any()))
.thenReturn(future(new Nat64InterfaceDetailsReplyDump()));
}
}
private void mockPostRoutingDump() {
- final SnatInterfaceOutputFeatureDetailsReplyDump details = new SnatInterfaceOutputFeatureDetailsReplyDump();
- final SnatInterfaceOutputFeatureDetails detail = new SnatInterfaceOutputFeatureDetails();
+ final Nat44InterfaceOutputFeatureDetailsReplyDump details = new Nat44InterfaceOutputFeatureDetailsReplyDump();
+ final Nat44InterfaceOutputFeatureDetails detail = new Nat44InterfaceOutputFeatureDetails();
detail.isInside = 0;
detail.swIfIndex = IFC_IDX;
- details.snatInterfaceOutputFeatureDetails = Lists.newArrayList(detail);
- when(jvppSnat.snatInterfaceOutputFeatureDump(any())).thenReturn(future(details));
+ details.nat44InterfaceOutputFeatureDetails = Lists.newArrayList(detail);
+ when(jvppNat.nat44InterfaceOutputFeatureDump(any())).thenReturn(future(details));
}
@Test
public void testPresencePreRouting() throws Exception {
- final SnatInterfaceDetailsReplyDump details = new SnatInterfaceDetailsReplyDump();
- final SnatInterfaceDetails detail = new SnatInterfaceDetails();
+ final Nat44InterfaceDetailsReplyDump details = new Nat44InterfaceDetailsReplyDump();
+ final Nat44InterfaceDetails detail = new Nat44InterfaceDetails();
detail.isInside = 0;
detail.swIfIndex = IFC_IDX;
- details.snatInterfaceDetails = Lists.newArrayList(detail);
- when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(details));
+ details.nat44InterfaceDetails = Lists.newArrayList(detail);
+ when(jvppNat.nat44InterfaceDump(any())).thenReturn(future(details));
assertTrue(getReader().read(id, ctx).isPresent());
}
@Override
protected ReaderCustomizer<Outbound, OutboundBuilder> initCustomizer() {
- return new InterfaceOutboundNatCustomizer(jvppSnat, ifcContext);
+ return new InterfaceOutboundNatCustomizer(jvppNat, ifcContext);
}
}
\ No newline at end of file
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
-import io.fd.vpp.jvpp.snat.dto.SnatStaticMappingDetails;
+import io.fd.vpp.jvpp.nat.dto.Nat44StaticMappingDetails;
import java.util.Collections;
import java.util.List;
import org.junit.Before;
final long natId = 0;
final long entryId = 12;
final MappingEntry entry = getEntry(entryId, "192.168.1.5", "17.14.4.6");
- final SnatStaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
+ final Nat44StaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
when(mappingCtx.read(MappingEntryContext.getId(natId, MappingEntryContext.entryToKey(entry))))
.thenReturn(Optional.of(MappingEntryContext.toCtxMapEntry(entry, entryId)));
public void testFindDetails() throws Exception {
final long natId = 0;
final MappingEntry entry = getEntry(0, "192.168.1.5", "17.14.4.6");
- final SnatStaticMappingDetails details = getDetails(0, "192.168.1.5", "17.14.4.6");
+ final Nat44StaticMappingDetails details = getDetails(0, "192.168.1.5", "17.14.4.6");
final MappingEntry entry2 = getEntry(1, "192.168.1.8", "17.14.4.10");
- final SnatStaticMappingDetails details2 = getDetails(1, "192.168.1.8", "17.14.4.10");
+ final Nat44StaticMappingDetails details2 = getDetails(1, "192.168.1.8", "17.14.4.10");
- final List<SnatStaticMappingDetails> someDetails = Lists.newArrayList(details, details2);
+ final List<Nat44StaticMappingDetails> someDetails = Lists.newArrayList(details, details2);
when(mappingCtx.read(MappingEntryContext.getTableId(natId)))
.thenReturn(Optional.of(new MappingTableBuilder()
public void testFindDetailsNoMappingStored() throws Exception {
final long natId = 0;
final long entryId = 12;
- final SnatStaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
- final List<SnatStaticMappingDetails> someDetails = Lists.newArrayList(details);
+ final Nat44StaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
+ final List<Nat44StaticMappingDetails> someDetails = Lists.newArrayList(details);
when(mappingCtx.read(MappingEntryContext.getTableId(natId))).thenReturn(Optional.absent());
ctx.findDetailsNat44(someDetails, natId, entryId, mappingCtx);
public void testFindDetailsNoMappingStored2() throws Exception {
final long natId = 0;
final long entryId = 12;
- final SnatStaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
- final List<SnatStaticMappingDetails> someDetails = Lists.newArrayList(details);
+ final Nat44StaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
+ final List<Nat44StaticMappingDetails> someDetails = Lists.newArrayList(details);
when(mappingCtx.read(MappingEntryContext.getTableId(natId)))
.thenReturn(Optional.of(new MappingTableBuilder().setMappingEntry(Collections.emptyList()).build()));
final long newEntryId = 18956;
final MappingEntry newEntry = getEntry(newEntryId, "192.168.1.99", "17.14.4.99");
- final SnatStaticMappingDetails newDetails = getDetails(newEntryId, "192.168.1.99", "17.14.4.99");
+ final Nat44StaticMappingDetails newDetails = getDetails(newEntryId, "192.168.1.99", "17.14.4.99");
when(mappingCtx.read(MappingEntryContext.getId(natId, MappingEntryContext.entryToKey(newEntry))))
.thenReturn(Optional.absent());
assertEquals(newEntryId, ctx.getStoredOrArtificialIndex(natId, newDetails, mappingCtx));
}
- private SnatStaticMappingDetails getDetails(final long vrfId, final String localIp, final String externIp) {
- final SnatStaticMappingDetails snatStaticMappingDetails = new SnatStaticMappingDetails();
- snatStaticMappingDetails.vrfId = (int) vrfId;
- snatStaticMappingDetails.addrOnly = 1;
- snatStaticMappingDetails.isIp4 = 1;
- snatStaticMappingDetails.localIpAddress = ipv4AddressNoZoneToArray(localIp);
- snatStaticMappingDetails.externalIpAddress = ipv4AddressNoZoneToArray(externIp);
- return snatStaticMappingDetails;
+ private Nat44StaticMappingDetails getDetails(final long vrfId, final String localIp, final String externIp) {
+ final Nat44StaticMappingDetails nat44StaticMappingDetails = new Nat44StaticMappingDetails();
+ nat44StaticMappingDetails.vrfId = (int) vrfId;
+ nat44StaticMappingDetails.addrOnly = 1;
+ nat44StaticMappingDetails.localIpAddress = ipv4AddressNoZoneToArray(localIp);
+ nat44StaticMappingDetails.externalIpAddress = ipv4AddressNoZoneToArray(externIp);
+ return nat44StaticMappingDetails;
}
@Test(expected = IllegalArgumentException.class)
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelPoolAddrRange;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelPoolAddrRangeReply;
-import io.fd.vpp.jvpp.snat.dto.SnatAddAddressRange;
-import io.fd.vpp.jvpp.snat.dto.SnatAddAddressRangeReply;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelAddressRange;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelAddressRangeReply;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelPoolAddrRange;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelPoolAddrRangeReply;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
private static final String NAT_INSTANCES_PATH = "/ietf-nat:nat-config/ietf-nat:nat-instances";
@Mock
- private FutureJVppSnatFacade jvppSnat;
+ private FutureJVppNatFacade jvppNat;
private ExternalIpPoolCustomizer customizer;
@Override
public void setUpTest() {
- customizer = new ExternalIpPoolCustomizer(jvppSnat);
- when(jvppSnat.snatAddAddressRange(any())).thenReturn(future(new SnatAddAddressRangeReply()));
- when(jvppSnat.nat64AddDelPoolAddrRange(any())).thenReturn(future(new Nat64AddDelPoolAddrRangeReply()));
+ customizer = new ExternalIpPoolCustomizer(jvppNat);
+ when(jvppNat.nat44AddDelAddressRange(any())).thenReturn(future(new Nat44AddDelAddressRangeReply()));
+ when(jvppNat.nat64AddDelPoolAddrRange(any())).thenReturn(future(new Nat64AddDelPoolAddrRangeReply()));
}
@Test
@InjectTestData(resourcePath = "/nat44/external-ip-pool.json", id = NAT_INSTANCES_PATH) NatInstances data)
throws WriteFailedException {
customizer.writeCurrentAttributes(IID, extractIpPool(data), writeContext);
- final SnatAddAddressRange expectedRequest = getExpectedRequestNat44(true);
- verify(jvppSnat).snatAddAddressRange(expectedRequest);
+ final Nat44AddDelAddressRange expectedRequest = getExpectedRequestNat44(true);
+ verify(jvppNat).nat44AddDelAddressRange(expectedRequest);
}
@Test
throws WriteFailedException {
customizer.writeCurrentAttributes(IID, extractIpPool(data), writeContext);
final Nat64AddDelPoolAddrRange expectedRequest = getExpectedRequestNat64(true);
- verify(jvppSnat).nat64AddDelPoolAddrRange(expectedRequest);
+ verify(jvppNat).nat64AddDelPoolAddrRange(expectedRequest);
}
@Test(expected = UnsupportedOperationException.class)
@InjectTestData(resourcePath = "/nat44/external-ip-pool.json", id = NAT_INSTANCES_PATH) NatInstances data)
throws WriteFailedException {
customizer.deleteCurrentAttributes(IID, extractIpPool(data), writeContext);
- final SnatAddAddressRange expectedRequest = getExpectedRequestNat44(false);
- verify(jvppSnat).snatAddAddressRange(expectedRequest);
+ final Nat44AddDelAddressRange expectedRequest = getExpectedRequestNat44(false);
+ verify(jvppNat).nat44AddDelAddressRange(expectedRequest);
}
@Test
throws WriteFailedException {
customizer.deleteCurrentAttributes(IID, extractIpPool(data), writeContext);
final Nat64AddDelPoolAddrRange expectedRequest = getExpectedRequestNat64(false);
- verify(jvppSnat).nat64AddDelPoolAddrRange(expectedRequest);
+ verify(jvppNat).nat64AddDelPoolAddrRange(expectedRequest);
}
private static ExternalIpAddressPool extractIpPool(NatInstances data) {
return data.getNatInstance().get(0).getExternalIpAddressPool().get(0);
}
- private SnatAddAddressRange getExpectedRequestNat44(final boolean isAdd) {
- final SnatAddAddressRange expectedRequest = new SnatAddAddressRange();
+ private Nat44AddDelAddressRange getExpectedRequestNat44(final boolean isAdd) {
+ final Nat44AddDelAddressRange expectedRequest = new Nat44AddDelAddressRange();
expectedRequest.isAdd = booleanToByte(isAdd);
- expectedRequest.isIp4 = 1;
expectedRequest.firstIpAddress = new byte[] {(byte) 192, (byte) 168, 1, 0};
expectedRequest.lastIpAddress = new byte[] {(byte) 192, (byte) 168, 1, (byte) 255};
return expectedRequest;
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelStaticBib;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelStaticBibReply;
-import io.fd.vpp.jvpp.snat.dto.SnatAddStaticMapping;
-import io.fd.vpp.jvpp.snat.dto.SnatAddStaticMappingReply;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelStaticMapping;
+import io.fd.vpp.jvpp.nat.dto.Nat44AddDelStaticMappingReply;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelStaticBib;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelStaticBibReply;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+ "ietf-nat:nat-instance[ietf-nat:id='" + NAT_INSTANCE_ID + "']/ietf-nat:mapping-table";
@Mock
- private FutureJVppSnatFacade jvppSnat;
+ private FutureJVppNatFacade jvppNat;
@Mock
private MappingEntryContext mappingContext;
private MappingEntryCustomizer customizer;
@Override
public void setUpTest() {
- customizer = new MappingEntryCustomizer(jvppSnat, mappingContext);
- when(jvppSnat.snatAddStaticMapping(any())).thenReturn(future(new SnatAddStaticMappingReply()));
- when(jvppSnat.nat64AddDelStaticBib(any())).thenReturn(future(new Nat64AddDelStaticBibReply()));
+ customizer = new MappingEntryCustomizer(jvppNat, mappingContext);
+ when(jvppNat.nat44AddDelStaticMapping(any())).thenReturn(future(new Nat44AddDelStaticMappingReply()));
+ when(jvppNat.nat64AddDelStaticBib(any())).thenReturn(future(new Nat64AddDelStaticBibReply()));
}
@Test
@InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data)
throws WriteFailedException {
customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext);
- final SnatAddStaticMapping expectedRequest = getExpectedNat44Request();
+ final Nat44AddDelStaticMapping expectedRequest = getExpectedNat44Request();
expectedRequest.isAdd = 1;
- verify(jvppSnat).snatAddStaticMapping(expectedRequest);
+ verify(jvppNat).nat44AddDelStaticMapping(expectedRequest);
}
@Test
customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext);
final Nat64AddDelStaticBib expectedRequest = getExpectedNat64Request();
expectedRequest.isAdd = 1;
- verify(jvppSnat).nat64AddDelStaticBib(expectedRequest);
+ verify(jvppNat).nat64AddDelStaticBib(expectedRequest);
}
@Test(expected = IllegalArgumentException.class)
throws WriteFailedException {
customizer.updateCurrentAttributes(IID, extractMappingEntry(before), extractMappingEntry(after), writeContext);
final Nat64AddDelStaticBib expectedDeleteRequest = getExpectedNat64Request();
- verify(jvppSnat).nat64AddDelStaticBib(expectedDeleteRequest);
+ verify(jvppNat).nat64AddDelStaticBib(expectedDeleteRequest);
final Nat64AddDelStaticBib expectedUpdateRequest = getExpectedNat64UpdateRequest();
expectedUpdateRequest.isAdd = 1;
- verify(jvppSnat).nat64AddDelStaticBib(expectedUpdateRequest);
+ verify(jvppNat).nat64AddDelStaticBib(expectedUpdateRequest);
}
@Test
@InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data)
throws WriteFailedException {
customizer.deleteCurrentAttributes(IID, extractMappingEntry(data), writeContext);
- verify(jvppSnat).snatAddStaticMapping(getExpectedNat44Request());
+ verify(jvppNat).nat44AddDelStaticMapping(getExpectedNat44Request());
}
@Test
@InjectTestData(resourcePath = "/nat64/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data)
throws WriteFailedException {
customizer.deleteCurrentAttributes(IID, extractMappingEntry(data), writeContext);
- verify(jvppSnat).nat64AddDelStaticBib(getExpectedNat64Request());
+ verify(jvppNat).nat64AddDelStaticBib(getExpectedNat64Request());
}
private static MappingEntry extractMappingEntry(MappingTable data) {
return data.getMappingEntry().get(0);
}
- private static SnatAddStaticMapping getExpectedNat44Request() {
- final SnatAddStaticMapping expectedRequest = new SnatAddStaticMapping();
- expectedRequest.isIp4 = 1;
+ private static Nat44AddDelStaticMapping getExpectedNat44Request() {
+ final Nat44AddDelStaticMapping expectedRequest = new Nat44AddDelStaticMapping();
expectedRequest.addrOnly = 1;
expectedRequest.protocol = 17; // udp
expectedRequest.vrfId = (int) NAT_INSTANCE_ID;
return expectedRequest;
}
- private static SnatAddStaticMapping getExpectedNat44UpdateRequest() {
- final SnatAddStaticMapping expectedRequest = new SnatAddStaticMapping();
- expectedRequest.isIp4 = 1;
+ private static Nat44AddDelStaticMapping getExpectedNat44UpdateRequest() {
+ final Nat44AddDelStaticMapping expectedRequest = new Nat44AddDelStaticMapping();
expectedRequest.addrOnly = 1;
expectedRequest.protocol = 17; // udp
expectedRequest.vrfId = (int) NAT_INSTANCE_ID;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelInterface;
-import io.fd.vpp.jvpp.snat.dto.Nat64AddDelInterfaceReply;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelFeature;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelFeatureReply;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelOutputFeature;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceAddDelOutputFeatureReply;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelFeature;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelFeatureReply;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelOutputFeature;
+import io.fd.vpp.jvpp.nat.dto.Nat44InterfaceAddDelOutputFeatureReply;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelInterface;
+import io.fd.vpp.jvpp.nat.dto.Nat64AddDelInterfaceReply;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170816.InterfaceNatVppFeatureAttributes;
private T customizer;
@Mock
- private FutureJVppSnatFacade snatApi;
+ private FutureJVppNatFacade natApi;
private NamingContext ifcNamingCtx = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
@Override
public void setUpTest() {
- customizer = getCustomizer(snatApi, ifcNamingCtx);
+ customizer = getCustomizer(natApi, ifcNamingCtx);
defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
- when(snatApi.snatInterfaceAddDelFeature(any())).thenReturn(future(new SnatInterfaceAddDelFeatureReply()));
- when(snatApi.snatInterfaceAddDelOutputFeature(any()))
- .thenReturn(future(new SnatInterfaceAddDelOutputFeatureReply()));
- when(snatApi.nat64AddDelInterface(any())).thenReturn(future(new Nat64AddDelInterfaceReply()));
+ when(natApi.nat44InterfaceAddDelFeature(any())).thenReturn(future(new Nat44InterfaceAddDelFeatureReply()));
+ when(natApi.nat44InterfaceAddDelOutputFeature(any()))
+ .thenReturn(future(new Nat44InterfaceAddDelOutputFeatureReply()));
+ when(natApi.nat64AddDelInterface(any())).thenReturn(future(new Nat64AddDelInterfaceReply()));
}
@Test
public void testWritePostRouting() throws Exception {
final D data = getPostRoutingConfig();
customizer.writeCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
- verify(snatApi).snatInterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, true));
- verify(snatApi, never()).nat64AddDelInterface(any()); // VPP does not support it currently
+ verify(natApi).nat44InterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, true));
+ verify(natApi, never()).nat64AddDelInterface(any()); // VPP does not support it currently
}
@Test(expected = UnsupportedOperationException.class)
public void testDeletePostRouting() throws Exception {
final D data = getPostRoutingConfig();
customizer.deleteCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
- verify(snatApi).snatInterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, false));
- verify(snatApi, never()).nat64AddDelInterface(any()); // VPP does not support it currently
+ verify(natApi).nat44InterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, false));
+ verify(natApi, never()).nat64AddDelInterface(any()); // VPP does not support it currently
}
private void verifyPreRouting(final D data, final boolean isAdd) {
if (data.isNat44Support()) {
- verify(snatApi).snatInterfaceAddDelFeature(expectedPreRoutingNat44Request(data, isAdd));
+ verify(natApi).nat44InterfaceAddDelFeature(expectedPreRoutingNat44Request(data, isAdd));
} else {
- verify(snatApi, never()).snatInterfaceAddDelFeature(any());
+ verify(natApi, never()).nat44InterfaceAddDelFeature(any());
}
if (data.isNat64Support() != null && data.isNat64Support()) {
- verify(snatApi).nat64AddDelInterface(expectedPreRoutingNat64Request(data, isAdd));
+ verify(natApi).nat64AddDelInterface(expectedPreRoutingNat64Request(data, isAdd));
} else {
- verify(snatApi, never()).nat64AddDelInterface(any());
+ verify(natApi, never()).nat64AddDelInterface(any());
}
}
- private SnatInterfaceAddDelFeature expectedPreRoutingNat44Request(final D data, boolean isAdd) {
- SnatInterfaceAddDelFeature request = new SnatInterfaceAddDelFeature();
+ private Nat44InterfaceAddDelFeature expectedPreRoutingNat44Request(final D data, boolean isAdd) {
+ Nat44InterfaceAddDelFeature request = new Nat44InterfaceAddDelFeature();
request.isInside = booleanToByte(data instanceof Inbound);
request.swIfIndex = IFACE_ID;
request.isAdd = booleanToByte(isAdd);
return request;
}
- private SnatInterfaceAddDelOutputFeature expectedPostRoutingRequest(final D data, boolean isAdd) {
- SnatInterfaceAddDelOutputFeature request = new SnatInterfaceAddDelOutputFeature();
+ private Nat44InterfaceAddDelOutputFeature expectedPostRoutingRequest(final D data, boolean isAdd) {
+ Nat44InterfaceAddDelOutputFeature request = new Nat44InterfaceAddDelOutputFeature();
request.isInside = booleanToByte(data instanceof Inbound);
request.swIfIndex = IFACE_ID;
request.isAdd = booleanToByte(isAdd);
protected abstract InstanceIdentifier<D> getIId(final String ifaceName);
- protected abstract T getCustomizer(final FutureJVppSnatFacade snatApi, final NamingContext ifcNamingCtx);
+ protected abstract T getCustomizer(final FutureJVppNatFacade natApi, final NamingContext ifcNamingCtx);
}
\ No newline at end of file
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
}
@Override
- protected InterfaceInboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi,
+ protected InterfaceInboundNatCustomizer getCustomizer(final FutureJVppNatFacade natApi,
final NamingContext ifcNamingCtx) {
- return new InterfaceInboundNatCustomizer(snatApi, ifcNamingCtx);
+ return new InterfaceInboundNatCustomizer(natApi, ifcNamingCtx);
}
}
\ No newline at end of file
package io.fd.hc2vpp.nat.write.ifc;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
}
@Override
- protected InterfaceOutboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi,
+ protected InterfaceOutboundNatCustomizer getCustomizer(final FutureJVppNatFacade natApi,
final NamingContext ifcNamingCtx) {
- return new InterfaceOutboundNatCustomizer(snatApi, ifcNamingCtx);
+ return new InterfaceOutboundNatCustomizer(natApi, ifcNamingCtx);
}
}
\ No newline at end of file
"helperAttributes": {},
"time": 1475154424741,
"name": "Set NAT outbound for ifc - cfg",
- "description": "Setting interface NAT outbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT outbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"outbound\" : {}\r\n \r\n}",
"helperAttributes": {},
"time": 1502799964039,
"name": "Add Nat64 address pool",
- "description": "CLI: vppctl nat64 add pool address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvppctl show nat64 pool\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.10/clicmd_src_plugins_snat.html#clicmd_nat64_add_pool_address",
+ "description": "CLI: vppctl nat64 add pool address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvppctl show nat64 pool\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n\t\"external-ip-address-pool\" : {\r\n\t\t\"pool-id\": 1,\r\n\t\t\"external-ip-pool\": \"172.16.2.0/30\",\r\n \"vpp-nat:pool-type\": \"nat64\"\r\n\t}\r\n}"
"helperAttributes": {},
"time": 1501658658435,
"name": "Set NAT inbound for ifc (post routing) - cfg",
- "description": "Setting interface NAT inbound output-feature (post routing)\n\nCLI: set interface snat in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT inbound output-feature (post routing)\n\nCLI: set interface nat44 in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"inbound\" : {\r\n \t\"post-routing\" : true\r\n }\r\n \r\n}",
"helperAttributes": {},
"time": 1502969752143,
"name": "Disable NAT64 inbound for ifc - cfg",
- "description": "Disabling interface NAT64 inbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Disabling interface NAT64 inbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": ""
"helperAttributes": {},
"time": 1502969982987,
"name": "Delete NAT64 static BIB entry -cfg",
- "description": "CLI: nat64 add static bib 2001:db8:85a3::8a2e:370:7334 1234 10.1.1.3 5678 tcp del\n\nMore information: https://wiki.fd.io/view/VPP/SNAT#Stateful_NAT64",
+ "description": "CLI: nat64 add static bib 2001:db8:85a3::8a2e:370:7334 1234 10.1.1.3 5678 tcp del\n\nMore information: https://wiki.fd.io/view/VPP/NAT#Stateful_NAT64",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": ""
"helperAttributes": {},
"time": 1502969736196,
"name": "Set NAT64 outbound for ifc - cfg",
- "description": "Setting interface NAT64 outbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT64 outbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"outbound\" : {\r\n \t\"nat44-support\" : false,\r\n \t\"nat64-support\" : true\r\n }\r\n \r\n}"
"helperAttributes": {},
"time": 1487678255065,
"name": "Delete SNAT address pool",
- "description": "CLI: vppctl snat del address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvat# snat_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.07/clicmd_src_plugins_snat.html#clicmd_set_interface_snat",
+ "description": "CLI: vppctl nat44 del address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvat# nat44_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "",
"helperAttributes": {},
"time": 1498726954006,
"name": "Set NAT outbound for subifc - cfg",
- "description": "Setting sub-interface NAT outbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting sub-interface NAT outbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"outbound\" : {}\r\n \r\n}",
"helperAttributes": {},
"time": 1487676902330,
"name": "Add single address to pool",
- "description": "CLI: vppctl snat add address 172.16.2.123\n\nCan be verified with\nvat# snat_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.07/clicmd_src_plugins_snat.html#clicmd_set_interface_snat",
+ "description": "CLI: vppctl nat44 add address 172.16.2.123\n\nCan be verified with\nvat# nat44_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n\t\"external-ip-address-pool\" : {\r\n\t\t\"pool-id\": 2,\r\n\t\t\"external-ip-pool\": \"172.16.2.123/32\"\r\n\t}\r\n}",
"data": [],
"dataMode": "raw",
"name": "Disable NAT inbound for ifc - cfg",
- "description": "Unsetting interface NAT inbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting interface NAT inbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1475835912474,
"version": 2,
"helperAttributes": {},
"time": 1502970015631,
"name": "Delete Nat64 address pool",
- "description": "CLI: vppctl nat64 add pool address 172.16.2.0 - 172.16.2.4 del\n\nCan be verified with\nvppctl show nat64 pool\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.10/clicmd_src_plugins_snat.html#clicmd_nat64_add_pool_address",
+ "description": "CLI: vppctl nat64 add pool address 172.16.2.0 - 172.16.2.4 del\n\nCan be verified with\nvppctl show nat64 pool\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": ""
"helperAttributes": {},
"time": 1475758450889,
"name": "Add SNAT 1:1 static entry IPv4 -cfg",
- "description": "CLI: snat add static mapping local 10.0.0.3 external 4.4.4.4\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "CLI: nat44 add static mapping local 10.0.0.3 external 4.4.4.4\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n\t\"mapping-entry\" : {\r\n\t\t\"index\": 1,\r\n\t\t\"type\": \"static\",\r\n\t\t\"internal-src-address\": \"192.168.1.87\",\r\n\t\t\"external-src-address\": \"45.1.5.7\"\r\n\t}\r\n}",
"data": [],
"dataMode": "raw",
"name": "Disable NAT outbound for ifc - cfg",
- "description": "Unsetting interface NAT outbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting interface NAT outbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1475835941689,
"version": 2,
"helperAttributes": {},
"time": 1487676498064,
"name": "Add SNAT address pool",
- "description": "CLI: vppctl snat add address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvat# snat_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.07/clicmd_src_plugins_snat.html#clicmd_set_interface_snat",
+ "description": "CLI: vppctl nat44 add address 172.16.2.0 - 172.16.2.4\n\nCan be verified with\nvat# nat44_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n\t\"external-ip-address-pool\" : {\r\n\t\t\"pool-id\": 1,\r\n\t\t\"external-ip-pool\": \"172.16.2.0/30\"\r\n\t}\r\n}",
"helperAttributes": {},
"time": 1487678215755,
"name": "Delete single address",
- "description": "CLI: vppctl snat del address 172.16.2.123\n\nCan be verified with\nvat# snat_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/SNAT\nhttps://docs.fd.io/vpp/17.07/clicmd_src_plugins_snat.html#clicmd_set_interface_snat",
+ "description": "CLI: vppctl nat44 del address 172.16.2.123\n\nCan be verified with\nvat# nat44_address_dump\n\nMore information:\nhttps://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "",
"helperAttributes": {},
"time": 1501658393667,
"name": "Set NAT outbound for ifc (post routing) - cfg",
- "description": "Setting interface NAT outbound feature (post routing)\n\nCLI: set interface snat in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT outbound feature (post routing)\n\nCLI: set interface nat44 in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"outbound\" : {\r\n \t\"post-routing\" : true\r\n }\r\n \r\n}",
"helperAttributes": {},
"time": 1502969748622,
"name": "Disable NAT64 outbound for ifc - cfg",
- "description": "Disabling interface NAT64 outbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Disabling interface NAT64 outbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": ""
"helperAttributes": {},
"time": 1498726948962,
"name": "Disable NAT inbound for subifc - cfg",
- "description": "Unsetting sub-interface NAT inbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting sub-interface NAT inbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"inbound\" : {}\r\n \r\n}",
"helperAttributes": {},
"time": 1501658697686,
"name": "Disable NAT inbound for ifc (post routing) - cfg",
- "description": "Unsetting interface NAT inbound output-feature (post routing)\n\nCLI: set interface snat in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting interface NAT inbound output-feature (post routing)\n\nCLI: set interface nat44 in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "",
"helperAttributes": {},
"time": 1502272808631,
"name": "Add NAT64 static BIB entry -cfg",
- "description": "CLI: nat64 add static bib 2001:db8:85a3::8a2e:370:7334 1234 10.1.1.3 5678 tcp\n\nMore information: https://wiki.fd.io/view/VPP/SNAT#Stateful_NAT64",
+ "description": "CLI: nat64 add static bib 2001:db8:85a3::8a2e:370:7334 1234 10.1.1.3 5678 tcp\n\nMore information: https://wiki.fd.io/view/VPP/NAT#Stateful_NAT64",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\n \"mapping-entry\": {\n \"index\": 1,\n \"type\": \"static\",\n \"transport-protocol\": 6,\n \"internal-src-address\": \"2001:db8:85a3::8a2e:370:7334\",\n \"external-src-address\": \"10.1.1.3\",\n \"internal-src-port\": {\n \"single-port-number\": 1234\n },\n \"external-src-port\": {\n \"single-port-number\": 5678\n }\n }\n}"
"data": [],
"dataMode": "raw",
"name": "Disable NAT outbound for subifc - cfg",
- "description": "Unsetting sub-interface NAT outbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting sub-interface NAT outbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1498726898787,
"version": 2,
"data": [],
"dataMode": "raw",
"name": "Get NAT state",
- "description": "Read nat-state\n\nCLI: show snat [detail|verbose]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Read nat-state\n\nCLI: show nat44 [detail|verbose]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1475677867416,
"version": 2,
"helperAttributes": {},
"time": 1502969740040,
"name": "Set NAT64 inbound for ifc - cfg",
- "description": "Setting interface NAT64 inbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT64 inbound feature\n\nCLI: set interface nat64 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "{\r\n \r\n \"inbound\" : {\r\n \t\"nat44-support\" : false,\r\n \t\"nat64-support\" : true\r\n }\r\n \r\n}"
"helperAttributes": {},
"time": 1501658438697,
"name": "Disable NAT outbound for ifc (post routing) - cfg",
- "description": "Unsetting interface NAT outbound feature (post routing)\n\nCLI: set interface snat in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Unsetting interface NAT outbound feature (post routing)\n\nCLI: set interface nat44 in <intfc> out <intfc> output-feature [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"collectionId": "87e0bcaa-5031-9a2b-8a6b-329758310154",
"responses": [],
"rawModeData": "",
"data": [],
"dataMode": "raw",
"name": "Set NAT inbound for subifc - cfg",
- "description": "Setting sub-interface NAT inbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting sub-interface NAT inbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1498726706031,
"version": 2,
"data": [],
"dataMode": "raw",
"name": "Set NAT inbound for ifc - cfg",
- "description": "Setting interface NAT inbound feature\n\nCLI: set interface snat in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/SNAT",
+ "description": "Setting interface NAT inbound feature\n\nCLI: set interface nat44 in <intfc> out <intfc> [del]\n\nMore information: https://wiki.fd.io/view/VPP/NAT",
"descriptionFormat": "html",
"time": 1475154374071,
"version": 2,
<!-- TODO set snapshot version to project-vpp-version after VPP is released-->
<!--<project-vpp-snapshot-version>17.10</project-vpp-snapshot-version>-->
<project-vpp-snapshot-version>17.10-SNAPSHOT</project-vpp-snapshot-version>
- <project-snat-version>17.10</project-snat-version>
- <!-- TODO set snapshot version to project-snat-version after VPP is released-->
- <!--<project-snat-snapshot-version>17.10</project-snat-snapshot-version>-->
- <project-snat-snapshot-version>17.10-SNAPSHOT</project-snat-snapshot-version>
+ <project-nat-version>17.10</project-nat-version>
+ <!-- TODO set snapshot version to project-nat-version after VPP is released-->
+ <!--<project-nat-snapshot-version>17.10</project-nat-snapshot-version>-->
+ <project-nat-snapshot-version>17.10-SNAPSHOT</project-nat-snapshot-version>
<project-git-web>https://git.fd.io/cgit/hc2vpp/tree</project-git-web>
<project-infra-git-web>https://git.fd.io/cgit/honeycomb/tree</project-infra-git-web>
</attributes>
include::api_docs/futurejvppacl-yang-config-index.adoc[JVpp Acl plugin docs]
-include::api_docs/futurejvppsnat-yang-config-index.adoc[JVpp Snat plugin docs]
+include::api_docs/futurejvppnat-yang-config-index.adoc[JVpp Nat plugin docs]
include::api_docs/futurejvppnsh-yang-config-index.adoc[JVpp Nsh plugin docs]
cd build-vpp-native/vpp-api/java/
mvn install:install-file -Dfile=jvpp-registry-{project-vpp-version}.jar -DgroupId=io.fd.vpp -DartifactId=jvpp-registry -Dversion={project-vpp-snapshot-version} -Dpackaging=jar
mvn install:install-file -Dfile=jvpp-core-{project-vpp-version}.jar -DgroupId=io.fd.vpp -DartifactId=jvpp-core -Dversion={project-vpp-snapshot-version}-Dpackaging=jar
- cd ../../plugins/snat-plugin/
- mvn install:install-file -Dfile=jvpp-snat-{project-snat-version}.jar -DgroupId=io.fd.vpp -DartifactId=jvpp-snat -Dversion={project-snat-snapshot-version} -Dpackaging=jar
+ cd ../../plugins/nat-plugin/
+ mvn install:install-file -Dfile=jvpp-nat-{project-nat-version}.jar -DgroupId=io.fd.vpp -DartifactId=jvpp-nat -Dversion={project-nat-snapshot-version} -Dpackaging=jar
Now current Vpp is up and running and prepared for integration with HC.
import io.fd.vpp.jvpp.ioampot.future.FutureJVppIoampot
import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace
import io.fd.vpp.jvpp.nsh.future.FutureJVppNsh
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnat
+import io.fd.vpp.jvpp.nat.future.FutureJVppNat
import java.nio.charset.StandardCharsets
import java.nio.file.Files
private static def NL = System.lineSeparator()
// TODO - check if list of plugin classes can be generated based on list of modules enabled for doc generation
private static
- def PLUGIN_CLASSES = [FutureJVppCore.class, FutureJVppAcl.class, FutureJVppSnat.class, FutureJVppNsh.class,
+ def PLUGIN_CLASSES = [FutureJVppCore.class, FutureJVppAcl.class, FutureJVppNat.class, FutureJVppNsh.class,
FutureJVppIoamexport.class, FutureJVppIoampot.class, FutureJVppIoamtrace.class]
private static def TABLE_PART_MARK = "|"
import io.fd.hc2vpp.nat.NatModule;
import io.fd.vpp.jvpp.JVpp;
import io.fd.vpp.jvpp.JVppRegistry;
-import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
+import io.fd.vpp.jvpp.nat.future.FutureJVppNatFacade;
import java.io.IOException;
/**
public class MockNatModule extends NatModule {
public MockNatModule() {
- super(MockJVppSnatProvider.class);
+ super(MockJVppNatProvider.class);
}
- private static class MockJVppSnatProvider implements Provider<FutureJVppSnatFacade> {
+ private static class MockJVppNatProvider implements Provider<FutureJVppNatFacade> {
@Override
- public FutureJVppSnatFacade get() {
+ public FutureJVppNatFacade get() {
try {
- return new FutureJVppSnatFacade(noOpProxy(JVppRegistry.class), noOpProxy(JVpp.class));
+ return new FutureJVppNatFacade(noOpProxy(JVppRegistry.class), noOpProxy(JVpp.class));
} catch (IOException e) {
throw new IllegalStateException(e);
}
Code Review / hc2vpp.git / commitdiff