package io.fd.hc2vpp.nat.read.ifc;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
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 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;
import org.slf4j.Logger;
abstract class AbstractInterfaceNatCustomizer<C extends DataObject, B extends Builder<C>>
- implements InitializingReaderCustomizer<C, B> {
+ implements InitializingReaderCustomizer<C, B>, JvppReplyConsumer {
- private final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr;
+ private final FutureJVppSnatFacade jvppSnat;
+ private final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> preRoutingDumpMgr;
+ private final DumpCacheManager<SnatInterfaceOutputFeatureDetailsReplyDump, Void> postRoutingDumpMgr;
private final NamingContext ifcContext;
- AbstractInterfaceNatCustomizer(@Nonnull final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
+ AbstractInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
@Nonnull final NamingContext ifcContext) {
- this.dumpMgr = dumpMgr;
- this.ifcContext = ifcContext;
+ this.jvppSnat = requireNonNull(jvppSnat, "jvppSnat should not be null");
+ this.ifcContext = requireNonNull(ifcContext, "ifcContext should not be null");
+ this.preRoutingDumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
+ .withExecutor((id, params) -> getReplyForRead(
+ jvppSnat.snatInterfaceDump(new SnatInterfaceDump()).toCompletableFuture(), id))
+ .acceptOnly(SnatInterfaceDetailsReplyDump.class)
+ .build();
+ this.postRoutingDumpMgr =
+ new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceOutputFeatureDetailsReplyDump, Void>()
+ .withExecutor((id, params) -> getReplyForRead(
+ jvppSnat.snatInterfaceOutputFeatureDump(new SnatInterfaceOutputFeatureDump())
+ .toCompletableFuture(), id))
+ .acceptOnly(SnatInterfaceOutputFeatureDetailsReplyDump.class)
+ .build();
}
@Override
public void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id,
@Nonnull final B builder,
@Nonnull final ReadContext ctx) throws ReadFailedException {
- // NOOP
+ final String ifcName = getName(id);
+ getLog().debug("Reading NAT features on interface: {}", ifcName);
+ final int index = ifcContext.getIndex(ifcName, ctx.getMappingContext());
+
+ // There are no additional attributes for pre routing NAT, so it is enough to read post routing ifc mapping:
+ final Optional<SnatInterfaceOutputFeatureDetailsReplyDump> postRoutingDump =
+ postRoutingDumpMgr.getDump(id, ctx.getModificationCache(), null);
+
+ postRoutingDump.or(new SnatInterfaceOutputFeatureDetailsReplyDump()).snatInterfaceOutputFeatureDetails.stream()
+ .filter(snatIfcDetail -> snatIfcDetail.swIfIndex == index)
+ .filter(snatIfcDetail -> isExpectedNatType(snatIfcDetail.isInside))
+ .findFirst()
+ .ifPresent(snatIfcDetail -> setPostRouting(builder));
}
@Override
- public boolean isPresent(final InstanceIdentifier<C> id, final C built, final ReadContext ctx) throws ReadFailedException {
+ public boolean isPresent(final InstanceIdentifier<C> id, final C built, final ReadContext ctx)
+ throws ReadFailedException {
+ // In the post routing case, we can reuse default implementation:
+ if (InitializingReaderCustomizer.super.isPresent(id, built, ctx)) {
+ // post routing was set
+ return true;
+ }
+ // In the pre routing case, we need to inspect pre routing dump:
final String ifcName = getName(id);
- getLog().debug("Reading NAT features on interface: {}", ifcName);
+ getLog().debug("Checking NAT presence for interface: {}", ifcName);
final int index = ifcContext.getIndex(ifcName, ctx.getMappingContext());
- // Cache dump for each interface under the same key since this is all ifc dump
- final Optional<SnatInterfaceDetailsReplyDump> dump =
- dumpMgr.getDump(id, ctx.getModificationCache(), null);
+ // Cache dump for each interface under the same key since this is all ifc dump:
+ final Optional<SnatInterfaceDetailsReplyDump> preRoutingDump =
+ preRoutingDumpMgr.getDump(id, ctx.getModificationCache(), null);
- // Find entries for current ifc and if is marked as inside set the builder to return presence container
- return dump.or(new SnatInterfaceDetailsReplyDump()).snatInterfaceDetails.stream()
+ // Find entries for current ifc and if is marked as inside set the builder to return presence container:
+ return preRoutingDump.or(new SnatInterfaceDetailsReplyDump()).snatInterfaceDetails.stream()
.filter(snatIfcDetail -> snatIfcDetail.swIfIndex == index)
- .filter(this::isExpectedNatType)
- .findFirst()
- .isPresent();
- // Not setting data, just marking the builder to propagate empty container to indicate presence
+ .anyMatch(snatIfcDetail -> isExpectedNatType(snatIfcDetail.isInside));
+ // Not setting data, just marking the builder to propagate empty container to indicate presence.
}
protected String getName(final InstanceIdentifier<C> id) {
return id.firstKeyOf(Interface.class).getName();
}
- protected abstract Logger getLog();
+ abstract Logger getLog();
+
+ abstract boolean isExpectedNatType(final int isInside);
- abstract boolean isExpectedNatType(final SnatInterfaceDetails snatInterfaceDetails);
+ abstract void setPostRouting(final B builder);
}
import static com.google.common.base.Preconditions.checkNotNull;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
abstract class AbstractSubInterfaceNatCustomizer<C extends DataObject, B extends Builder<C>>
- extends AbstractInterfaceNatCustomizer<C, B> {
- AbstractSubInterfaceNatCustomizer(
- @Nonnull final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
- @Nonnull final NamingContext ifcContext) {
- super(dumpMgr, ifcContext);
+ extends AbstractInterfaceNatCustomizer<C, B> {
+ AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ @Nonnull final NamingContext ifcContext) {
+ super(jvppSnat, ifcContext);
}
@Override
protected String getName(final InstanceIdentifier<C> id) {
// TODO(HC2VPP-99): use SubInterfaceUtils after it is moved from v3po2vpp
final String parentInterfaceName =
- checkNotNull(id.firstKeyOf(Interface.class), "operational Interface identifier expected").getName();
+ checkNotNull(id.firstKeyOf(Interface.class), "operational Interface identifier expected").getName();
final Long subIfId = id.firstKeyOf(SubInterface.class).getIdentifier();
return String.format("%s.%d", parentInterfaceName, subIfId.intValue());
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.impl.read.GenericInitReader;
-import io.fd.honeycomb.translate.read.ReadFailedException;
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.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDump;
import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
private static final InstanceIdentifier<NatInterfaceStateAugmentation> NAT_AUG_ID =
IFC_ID.augmentation(NatInterfaceStateAugmentation.class);
private static final InstanceIdentifier<Nat> NAT_AUG_CONTAINER_ID = NAT_AUG_ID.child(Nat.class);
-
- private final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> snatIfcDumpMgr;
private final NamingContext ifcContext;
+ private final FutureJVppSnatFacade jvppSnat;
@Inject
public IfcNatReaderFactory(final FutureJVppSnatFacade jvppSnat,
@Named("interface-context") final NamingContext ifcContext) {
- this.snatIfcDumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
- .withExecutor(new SnatInterfaceExecutor(jvppSnat))
- .acceptOnly(SnatInterfaceDetailsReplyDump.class)
- .build();
+ this.jvppSnat = jvppSnat;
this.ifcContext = ifcContext;
}
registry.addStructuralReader(NAT_AUG_CONTAINER_ID, NatBuilder.class);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Inbound.class),
- new InterfaceInboundNatCustomizer(snatIfcDumpMgr, ifcContext)), IFC_ID);
+ new InterfaceInboundNatCustomizer(jvppSnat, ifcContext)), IFC_ID);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Outbound.class),
- new InterfaceOutboundNatCustomizer(snatIfcDumpMgr, ifcContext)), IFC_ID);
- }
-
- private static final class SnatInterfaceExecutor implements
- EntityDumpExecutor<SnatInterfaceDetailsReplyDump, Void>,
- JvppReplyConsumer {
-
- private final FutureJVppSnatFacade jvppSnat;
-
- SnatInterfaceExecutor(final FutureJVppSnatFacade jvppSnat) {
- this.jvppSnat = jvppSnat;
- }
-
- @Nonnull
- @Override
- public SnatInterfaceDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final Void params)
- throws ReadFailedException {
- return getReplyForRead(
- jvppSnat.snatInterfaceDump(new SnatInterfaceDump()).toCompletableFuture(), identifier);
- }
+ new InterfaceOutboundNatCustomizer(jvppSnat, 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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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 DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
- @Nonnull final NamingContext ifcContext) {
- super(dumpMgr, ifcContext);
+ InterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ @Nonnull final NamingContext ifcContext) {
+ super(jvppSnat, ifcContext);
}
@Override
}
@Override
- boolean isExpectedNatType(final SnatInterfaceDetails snatInterfaceDetails) {
- return snatInterfaceDetails.isInside == 1;
+ boolean isExpectedNatType(final int isInside) {
+ return isInside == 1;
+ }
+
+ @Override
+ void setPostRouting(final InboundBuilder builder) {
+ builder.setPostRouting(true);
}
@Nonnull
@Nonnull final ReadContext ctx) {
final InstanceIdentifier<Inbound> cfgId =
InstanceIdentifier.create(Interfaces.class)
- .child(Interface.class,
- new InterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class).getName()))
- .augmentation(NatInterfaceAugmentation.class)
- .child(Nat.class)
- .child(Inbound.class);
+ .child(Interface.class,
+ new InterfaceKey(id.firstKeyOf(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class)
+ .getName()))
+ .augmentation(NatInterfaceAugmentation.class)
+ .child(Nat.class)
+ .child(Inbound.class);
return Initialized.create(cfgId, readValue);
}
}
package io.fd.hc2vpp.nat.read.ifc;
+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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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 DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
- @Nonnull final NamingContext ifcContext) {
- super(dumpMgr, ifcContext);
+ InterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ @Nonnull final NamingContext ifcContext) {
+ super(jvppSnat, ifcContext);
}
@Override
}
@Override
- boolean isExpectedNatType(final SnatInterfaceDetails snatInterfaceDetails) {
- return snatInterfaceDetails.isInside == 0;
+ boolean isExpectedNatType(final int isInside) {
+ return isInside == 0;
+ }
+
+ @Override
+ void setPostRouting(final OutboundBuilder builder) {
+ builder.setPostRouting(true);
}
@Nonnull
InstanceIdentifier.create(Interfaces.class)
.child(Interface.class,
new InterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class).getName()))
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class)
+ .getName()))
.augmentation(NatInterfaceAugmentation.class)
.child(Nat.class)
.child(Outbound.class);
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.impl.read.GenericInitReader;
-import io.fd.honeycomb.translate.read.ReadFailedException;
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.honeycomb.translate.util.read.cache.EntityDumpExecutor;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDump;
import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
private static final InstanceIdentifier<SubInterface>
SUB_IFC_ID = InstanceIdentifier.create(InterfacesState.class).child(Interface.class).augmentation(
- SubinterfaceStateAugmentation.class).child(SubInterfaces.class).child(SubInterface.class);
+ SubinterfaceStateAugmentation.class).child(SubInterfaces.class).child(SubInterface.class);
private static final InstanceIdentifier<NatSubinterfaceStateAugmentation> NAT_SUB_AUG_ID =
- SUB_IFC_ID.augmentation(NatSubinterfaceStateAugmentation.class);
+ SUB_IFC_ID.augmentation(NatSubinterfaceStateAugmentation.class);
private static final InstanceIdentifier<Nat> NAT_AUG_CONTAINER_ID = NAT_SUB_AUG_ID.child(Nat.class);
- private final DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> snatIfcDumpMgr;
private final NamingContext ifcContext;
+ private final FutureJVppSnatFacade jvppSnat;
@Inject
public SubIfcNatReaderFactory(final FutureJVppSnatFacade jvppSnat,
@Named("interface-context") final NamingContext ifcContext) {
- this.snatIfcDumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
- .withExecutor(new SnatInterfaceExecutor(jvppSnat))
- .acceptOnly(SnatInterfaceDetailsReplyDump.class)
- .build();
+ this.jvppSnat = jvppSnat;
this.ifcContext = ifcContext;
}
registry.addStructuralReader(NAT_AUG_CONTAINER_ID, NatBuilder.class);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Inbound.class),
- new SubInterfaceInboundNatCustomizer(snatIfcDumpMgr, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceInboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
registry.addAfter(new GenericInitReader<>(NAT_AUG_CONTAINER_ID.child(Outbound.class),
- new SubInterfaceOutboundNatCustomizer(snatIfcDumpMgr, ifcContext)), SUB_IFC_ID);
- }
-
- private static final class SnatInterfaceExecutor implements
- EntityDumpExecutor<SnatInterfaceDetailsReplyDump, Void>,
- JvppReplyConsumer {
-
- private final FutureJVppSnatFacade jvppSnat;
-
- SnatInterfaceExecutor(final FutureJVppSnatFacade jvppSnat) {
- this.jvppSnat = jvppSnat;
- }
-
- @Nonnull
- @Override
- public SnatInterfaceDetailsReplyDump executeDump(final InstanceIdentifier<?> identifier, final Void params)
- throws ReadFailedException {
- return getReplyForRead(
- jvppSnat.snatInterfaceDump(new SnatInterfaceDump()).toCompletableFuture(), identifier);
- }
+ new SubInterfaceOutboundNatCustomizer(jvppSnat, 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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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 DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
- @Nonnull final NamingContext ifcContext) {
- super(dumpMgr, ifcContext);
+ SubInterfaceInboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ @Nonnull final NamingContext ifcContext) {
+ super(jvppSnat, ifcContext);
}
@Override
}
@Override
- boolean isExpectedNatType(final SnatInterfaceDetails snatInterfaceDetails) {
- return snatInterfaceDetails.isInside == 1;
+ boolean isExpectedNatType(final int isInside) {
+ return isInside == 1;
+ }
+
+ @Override
+ void setPostRouting(final InboundBuilder builder) {
+ builder.setPostRouting(true);
}
@Nonnull
@Nonnull final Inbound readValue,
@Nonnull final ReadContext ctx) {
final InstanceIdentifier<Inbound> cfgId =
- InstanceIdentifier.create(Interfaces.class)
- .child(Interface.class,
- new InterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class).getName()))
- .augmentation(SubinterfaceAugmentation.class)
- .child(SubInterfaces.class)
- .child(SubInterface.class,
- new SubInterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces.state._interface.sub.interfaces.SubInterface.class).getIdentifier()))
- .augmentation(NatSubinterfaceAugmentation.class)
- .child(Nat.class)
- .child(Inbound.class);
+ InstanceIdentifier.create(Interfaces.class)
+ .child(Interface.class,
+ new InterfaceKey(id.firstKeyOf(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class)
+ .getName()))
+ .augmentation(SubinterfaceAugmentation.class)
+ .child(SubInterfaces.class)
+ .child(SubInterface.class,
+ new SubInterfaceKey(id.firstKeyOf(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces.state._interface.sub.interfaces.SubInterface.class)
+ .getIdentifier()))
+ .augmentation(NatSubinterfaceAugmentation.class)
+ .child(Nat.class)
+ .child(Inbound.class);
return Initialized.create(cfgId, readValue);
}
}
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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetails;
-import io.fd.vpp.jvpp.snat.dto.SnatInterfaceDetailsReplyDump;
+import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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 DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr,
- @Nonnull final NamingContext ifcContext) {
- super(dumpMgr, ifcContext);
+ SubInterfaceOutboundNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
+ @Nonnull final NamingContext ifcContext) {
+ super(jvppSnat, ifcContext);
}
@Override
}
@Override
- boolean isExpectedNatType(final SnatInterfaceDetails snatInterfaceDetails) {
- return snatInterfaceDetails.isInside == 0;
+ boolean isExpectedNatType(final int isInside) {
+ return isInside == 0;
+ }
+
+ @Override
+ void setPostRouting(final OutboundBuilder builder) {
+ builder.setPostRouting(true);
}
@Nonnull
@Nonnull final Outbound readValue,
@Nonnull final ReadContext ctx) {
final InstanceIdentifier<Outbound> cfgId =
- InstanceIdentifier.create(Interfaces.class)
- .child(Interface.class,
- new InterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class).getName()))
- .augmentation(SubinterfaceAugmentation.class)
- .child(SubInterfaces.class)
- .child(SubInterface.class,
- new SubInterfaceKey(id.firstKeyOf(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces.state._interface.sub.interfaces.SubInterface.class).getIdentifier()))
- .augmentation(NatSubinterfaceAugmentation.class)
- .child(Nat.class)
- .child(Outbound.class);
+ InstanceIdentifier.create(Interfaces.class)
+ .child(Interface.class,
+ new InterfaceKey(id.firstKeyOf(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class)
+ .getName()))
+ .augmentation(SubinterfaceAugmentation.class)
+ .child(SubInterfaces.class)
+ .child(SubInterface.class,
+ new SubInterfaceKey(id.firstKeyOf(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces.state._interface.sub.interfaces.SubInterface.class)
+ .getIdentifier()))
+ .augmentation(NatSubinterfaceAugmentation.class)
+ .child(Nat.class)
+ .child(Outbound.class);
return Initialized.create(cfgId, readValue);
}
}
package io.fd.hc2vpp.nat.write.ifc;
-import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.dto.JVppReply;
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 java.util.concurrent.CompletionStage;
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.rev170801.InterfaceNatVppFeatureAttributes;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
-abstract class AbstractInterfaceNatCustomizer<D extends DataObject> implements JvppReplyConsumer, WriterCustomizer<D> {
+abstract class AbstractInterfaceNatCustomizer<D extends InterfaceNatVppFeatureAttributes & DataObject>
+ implements ByteDataTranslator, JvppReplyConsumer, WriterCustomizer<D> {
private final FutureJVppSnatFacade jvppSnat;
private final NamingContext ifcContext;
@Nonnull final WriteContext writeContext) throws WriteFailedException {
final String ifcName = getName(id);
getLog().debug("Enabling " + getType() + " NAT on interface: {}", ifcName);
- getLog().debug("Enabling " + getType() + " NAT: {}", id);
+ getLog().debug("Enabling {} NAT: {}", dataAfter, id);
final int ifcIndex = ifcContext.getIndex(ifcName, writeContext.getMappingContext());
- final SnatInterfaceAddDelFeature request = getRequest(ifcIndex, (byte)1);
- final CompletionStage<SnatInterfaceAddDelFeatureReply> future = jvppSnat.snatInterfaceAddDelFeature(request);
-
- final SnatInterfaceAddDelFeatureReply reply = getReplyForWrite(future.toCompletableFuture(), id);
- getLog().debug("NAT " + getType() + " enabled successfully on: {}, reply: {}", ifcName, reply);
+ final JVppReply reply;
+ if (dataAfter.isPostRouting()) {
+ reply = postRoutingNat(id, ifcIndex, true);
+ } else {
+ reply = preRoutingNat(id, ifcIndex, true);
+ }
+ getLog().debug("NAT {} enabled successfully on: {}, reply: {}", dataAfter, ifcName, reply);
}
@Override
throws WriteFailedException {
final String ifcName = getName(id);
getLog().debug("Disabling " + getType() + " NAT on interface: {}", ifcName);
- getLog().debug("Disabling " + getType() + " NAT: {}", id);
+ getLog().debug("Disabling {} NAT: {}", dataBefore, id);
final int ifcIndex = ifcContext.getIndex(ifcName, writeContext.getMappingContext());
- final SnatInterfaceAddDelFeature request = getRequest(ifcIndex, (byte)0);
- final CompletionStage<SnatInterfaceAddDelFeatureReply> future = jvppSnat.snatInterfaceAddDelFeature(request);
-
- final SnatInterfaceAddDelFeatureReply reply = getReplyForWrite(future.toCompletableFuture(), id);
- getLog().debug("NAT " + getType() + " disabled successfully on: {}, reply: {}", ifcName, reply);
+ final JVppReply reply;
+ if (dataBefore.isPostRouting()) {
+ reply = postRoutingNat(id, ifcIndex, false);
+ } else {
+ reply = preRoutingNat(id, ifcIndex, false);
+ }
+ getLog().debug("NAT {} disabled successfully on: {}, reply: {}", dataBefore, ifcName, reply);
}
protected String getName(final InstanceIdentifier<D> id) {
return id.firstKeyOf(Interface.class).getName();
}
+ private JVppReply postRoutingNat(@Nonnull final InstanceIdentifier<D> id, final int ifcIndex, final boolean enable)
+ throws WriteFailedException {
+ final SnatInterfaceAddDelOutputFeature request = new SnatInterfaceAddDelOutputFeature();
+ request.isAdd = booleanToByte(enable);
+ request.isInside = getType().isInside;
+ request.swIfIndex = ifcIndex;
+
+ final CompletionStage<SnatInterfaceAddDelOutputFeatureReply> future =
+ jvppSnat.snatInterfaceAddDelOutputFeature(request);
+ return getReplyForWrite(future.toCompletableFuture(), id);
+ }
+
+ private JVppReply preRoutingNat(@Nonnull final InstanceIdentifier<D> id, final int ifcIndex, final boolean enable)
+ throws WriteFailedException {
+ final SnatInterfaceAddDelFeature request = new SnatInterfaceAddDelFeature();
+ request.isAdd = booleanToByte(enable);
+ request.isInside = getType().isInside;
+ request.swIfIndex = ifcIndex;
+
+ final CompletionStage<SnatInterfaceAddDelFeatureReply> future = jvppSnat.snatInterfaceAddDelFeature(request);
+ return getReplyForWrite(future.toCompletableFuture(), id);
+ }
+
enum NatType {
- INBOUND((byte)1), OUTBOUND((byte)0);
+ INBOUND((byte) 1), OUTBOUND((byte) 0);
private final byte isInside;
}
abstract NatType getType();
- abstract Logger getLog();
-
- private SnatInterfaceAddDelFeature getRequest(final int ifcIdx, final byte isAdd) {
- final SnatInterfaceAddDelFeature request = new SnatInterfaceAddDelFeature();
- request.isAdd = isAdd;
- request.isInside = getType().isInside;
- request.swIfIndex = ifcIdx;
- return request;
- }
+ abstract Logger getLog();
}
import io.fd.vpp.jvpp.snat.future.FutureJVppSnatFacade;
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.rev170801.InterfaceNatVppFeatureAttributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev170607.interfaces._interface.sub.interfaces.SubInterface;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-abstract class AbstractSubInterfaceNatCustomizer<D extends DataObject> extends AbstractInterfaceNatCustomizer<D> {
+abstract class AbstractSubInterfaceNatCustomizer<D extends InterfaceNatVppFeatureAttributes & DataObject>
+ extends AbstractInterfaceNatCustomizer<D> {
AbstractSubInterfaceNatCustomizer(@Nonnull final FutureJVppSnatFacade jvppSnat,
- @Nonnull final NamingContext ifcContext) {
+ @Nonnull final NamingContext ifcContext) {
super(jvppSnat, ifcContext);
}
protected String getName(final InstanceIdentifier<D> id) {
// TODO(HC2VPP-99): use SubInterfaceUtils after it is moved from v3po2vpp
final String parentInterfaceName =
- checkNotNull(id.firstKeyOf(Interface.class), "Interface configuration identifier expected").getName();
+ checkNotNull(id.firstKeyOf(Interface.class), "Interface configuration identifier expected").getName();
final Long subIfId = id.firstKeyOf(SubInterface.class).getIdentifier();
return String.format("%s.%d", parentInterfaceName, subIfId.intValue());
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.impl.write.GenericWriter;
import io.fd.hc2vpp.common.translate.util.NamingContext;
+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;
private static final InstanceIdentifier<Interface>
IFC_ID = InstanceIdentifier.create(Interfaces.class).child(Interface.class);
private static final InstanceIdentifier<Nat> NAT_AUG_ID =
- IFC_ID .augmentation(NatInterfaceAugmentation.class).child(Nat.class);
+ IFC_ID.augmentation(NatInterfaceAugmentation.class).child(Nat.class);
private final FutureJVppSnatFacade jvppSnat;
private final NamingContext ifcContext;
public final class SubIfcNatWriterFactory implements WriterFactory {
private static final InstanceIdentifier<SubInterface>
- SUB_IFC_ID = InstanceIdentifier.create(Interfaces.class).child(Interface.class).augmentation(
- SubinterfaceAugmentation.class).child(SubInterfaces.class).child(SubInterface.class);
+ SUB_IFC_ID = InstanceIdentifier.create(Interfaces.class).child(Interface.class).augmentation(
+ SubinterfaceAugmentation.class).child(SubInterfaces.class).child(SubInterface.class);
private static final InstanceIdentifier<Nat> NAT_AUG_ID =
- SUB_IFC_ID.augmentation(NatSubinterfaceAugmentation.class).child(Nat.class);
+ SUB_IFC_ID.augmentation(NatSubinterfaceAugmentation.class).child(Nat.class);
private final FutureJVppSnatFacade jvppSnat;
private final NamingContext 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(jvppSnat, ifcContext)), SUB_IFC_ID);
registry.addAfter(new GenericWriter<>(NAT_AUG_ID.child(Outbound.class),
- new SubInterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
+ new SubInterfaceOutboundNatCustomizer(jvppSnat, ifcContext)), SUB_IFC_ID);
}
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import com.google.common.collect.Lists;
import io.fd.hc2vpp.common.test.read.ReaderCustomizerTest;
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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
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 org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey;
private static final String CTX_NAME = "ifc";
@Mock
- private EntityDumpExecutor<SnatInterfaceDetailsReplyDump, Void> natExecutor;
- private DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr;
+ private FutureJVppSnatFacade jvppSnat;
+
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);
- // empty dump
- Mockito.doReturn(new SnatInterfaceDetailsReplyDump()).when(natExecutor).executeDump(id, null);
- dumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
- .withExecutor(natExecutor)
- .acceptOnly(SnatInterfaceDetailsReplyDump.class)
- .build();
+ when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(new SnatInterfaceDetailsReplyDump()));
+ when(jvppSnat.snatInterfaceOutputFeatureDump(any()))
+ .thenReturn(future(new SnatInterfaceOutputFeatureDetailsReplyDump()));
+ }
+
+ private GenericReader<Inbound, InboundBuilder> getReader() {
+ return new GenericReader<>(RWUtils.makeIidWildcarded(id), customizer);
}
@Test
assertFalse(getReader().read(id, ctx).isPresent());
}
- private GenericReader<Inbound, InboundBuilder> getReader() {
- return new GenericReader<>(RWUtils.makeIidWildcarded(id), customizer);
+ private void mockPostRoutingDump() {
+ final SnatInterfaceOutputFeatureDetailsReplyDump details = new SnatInterfaceOutputFeatureDetailsReplyDump();
+ final SnatInterfaceOutputFeatureDetails detail = new SnatInterfaceOutputFeatureDetails();
+ detail.isInside = 1;
+ detail.swIfIndex = IFC_IDX;
+ details.snatInterfaceOutputFeatureDetails = Lists.newArrayList(detail);
+ when(jvppSnat.snatInterfaceOutputFeatureDump(any())).thenReturn(future(details));
}
@Test
- public void testPresence() throws Exception {
+ public void testPresencePreRouting() throws Exception {
final SnatInterfaceDetailsReplyDump details = new SnatInterfaceDetailsReplyDump();
final SnatInterfaceDetails detail = new SnatInterfaceDetails();
detail.isInside = 1;
detail.swIfIndex = IFC_IDX;
details.snatInterfaceDetails = Lists.newArrayList(detail);
- Mockito.doReturn(details).when(natExecutor).executeDump(id, null);
+ when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(details));
+
+ assertTrue(getReader().read(id, ctx).isPresent());
+ }
+ @Test
+ public void testPresencePostRouting() throws Exception {
+ mockPostRoutingDump();
assertTrue(getReader().read(id, ctx).isPresent());
}
+ @Test
+ public void testReadPostRouting() throws Exception {
+ mockPostRoutingDump();
+ final InboundBuilder builder = mock(InboundBuilder.class);
+ customizer.readCurrentAttributes(id, builder, ctx);
+ verify(builder).setPostRouting(true);
+ }
+
@Override
protected ReaderCustomizer<Inbound, InboundBuilder> initCustomizer() {
- return new InterfaceInboundNatCustomizer(dumpMgr, ifcContext);
+ return new InterfaceInboundNatCustomizer(jvppSnat, ifcContext);
}
}
\ No newline at end of file
import static io.fd.hc2vpp.nat.read.ifc.InterfaceInboundNatCustomizerTest.getId;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import com.google.common.collect.Lists;
import io.fd.hc2vpp.common.test.read.ReaderCustomizerTest;
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.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
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 org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.NatBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.nat.Outbound;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.nat.OutboundBuilder;
private static final String CTX_NAME = "ifc";
@Mock
- private EntityDumpExecutor<SnatInterfaceDetailsReplyDump, Void> abc;
- private DumpCacheManager<SnatInterfaceDetailsReplyDump, Void> dumpMgr;
+ private FutureJVppSnatFacade jvppSnat;
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);
- // empty dump
- Mockito.doReturn(new SnatInterfaceDetailsReplyDump()).when(abc).executeDump(id, null);
- dumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<SnatInterfaceDetailsReplyDump, Void>()
- .withExecutor(abc)
- .acceptOnly(SnatInterfaceDetailsReplyDump.class)
- .build();
+ when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(new SnatInterfaceDetailsReplyDump()));
+ when(jvppSnat.snatInterfaceOutputFeatureDump(any()))
+ .thenReturn(future(new SnatInterfaceOutputFeatureDetailsReplyDump()));
+ }
+
+ private GenericReader<Outbound, OutboundBuilder> getReader() {
+ return new GenericReader<>(RWUtils.makeIidWildcarded(id), customizer);
}
@Test
assertFalse(getReader().read(id, ctx).isPresent());
}
- private GenericReader<Outbound, OutboundBuilder> getReader() {
- return new GenericReader<>(RWUtils.makeIidWildcarded(id), customizer);
+ private void mockPostRoutingDump() {
+ final SnatInterfaceOutputFeatureDetailsReplyDump details = new SnatInterfaceOutputFeatureDetailsReplyDump();
+ final SnatInterfaceOutputFeatureDetails detail = new SnatInterfaceOutputFeatureDetails();
+ detail.isInside = 0;
+ detail.swIfIndex = IFC_IDX;
+ details.snatInterfaceOutputFeatureDetails = Lists.newArrayList(detail);
+ when(jvppSnat.snatInterfaceOutputFeatureDump(any())).thenReturn(future(details));
}
@Test
- public void testPresence() throws Exception {
+ public void testPresencePreRouting() throws Exception {
final SnatInterfaceDetailsReplyDump details = new SnatInterfaceDetailsReplyDump();
final SnatInterfaceDetails detail = new SnatInterfaceDetails();
detail.isInside = 0;
detail.swIfIndex = IFC_IDX;
details.snatInterfaceDetails = Lists.newArrayList(detail);
- Mockito.doReturn(details).when(abc).executeDump(id, null);
+ when(jvppSnat.snatInterfaceDump(any())).thenReturn(future(details));
assertTrue(getReader().read(id, ctx).isPresent());
}
+ @Test
+ public void testPresencePostRouting() throws Exception {
+ mockPostRoutingDump();
+ assertTrue(getReader().read(id, ctx).isPresent());
+ }
+
+ @Test
+ public void testReadPostRouting() throws Exception {
+ mockPostRoutingDump();
+ final OutboundBuilder builder = mock(OutboundBuilder.class);
+ customizer.readCurrentAttributes(id, builder, ctx);
+ verify(builder).setPostRouting(true);
+ }
+
@Override
protected ReaderCustomizer<Outbound, OutboundBuilder> initCustomizer() {
- return new InterfaceOutboundNatCustomizer(dumpMgr, ifcContext);
+ return new InterfaceOutboundNatCustomizer(jvppSnat, ifcContext);
}
}
\ No newline at end of file
import io.fd.honeycomb.translate.write.WriteFailedException;
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 org.junit.Test;
import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801.InterfaceNatVppFeatureAttributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.nat.Inbound;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-abstract class AbstractNatCustomizerTest<D extends DataObject, T extends AbstractInterfaceNatCustomizer<D>>
- extends WriterCustomizerTest implements ByteDataTranslator {
+abstract class AbstractNatCustomizerTest<D extends InterfaceNatVppFeatureAttributes & DataObject, T extends AbstractInterfaceNatCustomizer<D>>
+ extends WriterCustomizerTest implements ByteDataTranslator {
private static final String IFC_CTX_NAME = "ifc-test-instance";
private static final String IFACE_NAME = "eth0";
@Override
public void setUpTest() {
customizer = getCustomizer(snatApi, 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()));
}
@Test
- public void testWrite() throws Exception {
- defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
- when(snatApi.snatInterfaceAddDelFeature(any())).thenReturn(future(new SnatInterfaceAddDelFeatureReply()));
- final D data = getData();
+ public void testWritePreRouting() throws Exception {
+ final D data = getPreRoutingConfig();
+ customizer.writeCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
+ verify(snatApi).snatInterfaceAddDelFeature(expectedPreRoutingRequest(data, true));
+ }
+
+ @Test
+ public void testWritePostRouting() throws Exception {
+ final D data = getPostRoutingConfig();
customizer.writeCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
- verify(snatApi).snatInterfaceAddDelFeature(expectedRequest(data, true));
+ verify(snatApi).snatInterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, true));
+ }
+
+ @Test(expected = WriteFailedException.UpdateFailedException.class)
+ public void testUpdatePreRouting() throws Exception {
+ customizer.updateCurrentAttributes(getIId(IFACE_NAME), getPreRoutingConfig(), getPreRoutingConfig(),
+ writeContext);
}
@Test(expected = WriteFailedException.UpdateFailedException.class)
- public void testUpdate() throws Exception {
- customizer.updateCurrentAttributes(getIId(IFACE_NAME), getData(), getData(), writeContext);
+ public void testUpdatePostRouting() throws Exception {
+ customizer.updateCurrentAttributes(getIId(IFACE_NAME), getPostRoutingConfig(), getPostRoutingConfig(),
+ writeContext);
}
@Test
- public void testDelete() throws Exception {
- defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
- when(snatApi.snatInterfaceAddDelFeature(any())).thenReturn(future(new SnatInterfaceAddDelFeatureReply()));
- final D data = getData();
+ public void testDeletePreRouting() throws Exception {
+ final D data = getPreRoutingConfig();
+ customizer.deleteCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
+ verify(snatApi).snatInterfaceAddDelFeature(expectedPreRoutingRequest(data, false));
+ }
+
+ @Test
+ public void testDeletePostRouting() throws Exception {
+ final D data = getPostRoutingConfig();
customizer.deleteCurrentAttributes(getIId(IFACE_NAME), data, writeContext);
- verify(snatApi).snatInterfaceAddDelFeature(expectedRequest(data, false));
+ verify(snatApi).snatInterfaceAddDelOutputFeature(expectedPostRoutingRequest(data, false));
}
- private SnatInterfaceAddDelFeature expectedRequest(final D data, boolean isAdd) {
+ private SnatInterfaceAddDelFeature expectedPreRoutingRequest(final D data, boolean isAdd) {
SnatInterfaceAddDelFeature request = new SnatInterfaceAddDelFeature();
- request.isInside = (byte) ((data instanceof Inbound) ? 1 : 0);
+ request.isInside = (byte) ((data instanceof Inbound)
+ ? 1
+ : 0);
request.swIfIndex = IFACE_ID;
request.isAdd = booleanToByte(isAdd);
return request;
}
- protected abstract D getData();
+ private SnatInterfaceAddDelOutputFeature expectedPostRoutingRequest(final D data, boolean isAdd) {
+ SnatInterfaceAddDelOutputFeature request = new SnatInterfaceAddDelOutputFeature();
+ request.isInside = (byte) ((data instanceof Inbound)
+ ? 1
+ : 0);
+ request.swIfIndex = IFACE_ID;
+ request.isAdd = booleanToByte(isAdd);
+ return request;
+ }
+
+ protected abstract D getPreRoutingConfig();
+
+ protected abstract D getPostRoutingConfig();
protected abstract InstanceIdentifier<D> getIId(final String ifaceName);
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.nat.InboundBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class InterfaceInboundNatCustomizerTest extends AbstractNatCustomizerTest<Inbound, InterfaceInboundNatCustomizer> {
+public class InterfaceInboundNatCustomizerTest
+ extends AbstractNatCustomizerTest<Inbound, InterfaceInboundNatCustomizer> {
@Override
- protected Inbound getData() {
- return new InboundBuilder().build();
+ protected Inbound getPreRoutingConfig() {
+ return new InboundBuilder().setPostRouting(false).build();
+ }
+
+ @Override
+ protected Inbound getPostRoutingConfig() {
+ return new InboundBuilder().setPostRouting(true).build();
}
@Override
protected InstanceIdentifier<Inbound> getIId(final String ifaceName) {
return InstanceIdentifier.create(Interfaces.class)
- .child(Interface.class, new InterfaceKey(ifaceName)).augmentation(NatInterfaceAugmentation.class)
- .child(Nat.class).child(Inbound.class);
+ .child(Interface.class, new InterfaceKey(ifaceName)).augmentation(NatInterfaceAugmentation.class)
+ .child(Nat.class).child(Inbound.class);
}
@Override
- protected InterfaceInboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi, final NamingContext ifcNamingCtx) {
+ protected InterfaceInboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi,
+ final NamingContext ifcNamingCtx) {
return new InterfaceInboundNatCustomizer(snatApi, ifcNamingCtx);
}
}
\ No newline at end of file
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.nat.rev170801._interface.nat.attributes.nat.OutboundBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class InterfaceOutboundNatCustomizerTest extends AbstractNatCustomizerTest<Outbound, InterfaceOutboundNatCustomizer> {
+public class InterfaceOutboundNatCustomizerTest
+ extends AbstractNatCustomizerTest<Outbound, InterfaceOutboundNatCustomizer> {
@Override
- protected Outbound getData() {
- return new OutboundBuilder().build();
+ protected Outbound getPreRoutingConfig() {
+ return new OutboundBuilder().setPostRouting(false).build();
+ }
+
+ @Override
+ protected Outbound getPostRoutingConfig() {
+ return new OutboundBuilder().setPostRouting(true).build();
}
@Override
protected InstanceIdentifier<Outbound> getIId(final String ifaceName) {
return InstanceIdentifier.create(Interfaces.class)
- .child(Interface.class, new InterfaceKey(ifaceName)).augmentation(NatInterfaceAugmentation.class)
- .child(Nat.class).child(Outbound.class);
+ .child(Interface.class, new InterfaceKey(ifaceName)).augmentation(NatInterfaceAugmentation.class)
+ .child(Nat.class).child(Outbound.class);
}
@Override
- protected InterfaceOutboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi, final NamingContext ifcNamingCtx) {
+ protected InterfaceOutboundNatCustomizer getCustomizer(final FutureJVppSnatFacade snatApi,
+ final NamingContext ifcNamingCtx) {
return new InterfaceOutboundNatCustomizer(snatApi, ifcNamingCtx);
}
}
\ No newline at end of file
Code Review / hc2vpp.git / commitdiff