From b9e58bf303a099805ecb24ca3a97027b3c34a211 Mon Sep 17 00:00:00 2001 From: Marek Gradzki Date: Wed, 20 Jun 2018 16:37:06 +0200 Subject: HC2VPP-88: translation layer for af_packet interface management Includes postman collection with RESTCONF examples. Change-Id: If6f7ba1e2e7ab37433ebc5215e4731f1193c62a2 Signed-off-by: Marek Gradzki --- v3po/v3po2vpp/asciidoc/Readme.adoc | 2 + .../v3po/factory/InterfacesStateReaderFactory.java | 5 + .../v3po/factory/InterfacesWriterFactory.java | 10 +- .../hc2vpp/v3po/interfaces/AfPacketCustomizer.java | 127 +++++++++++++++++++ .../v3po/interfacesstate/AfPacketCustomizer.java | 136 +++++++++++++++++++++ .../interfacesstate/InterfaceDataTranslator.java | 5 + .../v3po/interfaces/AfPacketCustomizerTest.java | 112 +++++++++++++++++ .../interfacesstate/AfPacketCustomizerTest.java | 127 +++++++++++++++++++ .../InterfaceDataTranslatorTest.java | 3 + 9 files changed, 525 insertions(+), 2 deletions(-) create mode 100644 v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizer.java create mode 100644 v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizer.java create mode 100644 v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizerTest.java create mode 100644 v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizerTest.java (limited to 'v3po/v3po2vpp') diff --git a/v3po/v3po2vpp/asciidoc/Readme.adoc b/v3po/v3po2vpp/asciidoc/Readme.adoc index db779a10b..639e2fba1 100644 --- a/v3po/v3po2vpp/asciidoc/Readme.adoc +++ b/v3po/v3po2vpp/asciidoc/Readme.adoc @@ -9,6 +9,7 @@ Current order of v3po-api writers is: . BridgeDomain . VhostUser +. AfPacket . VxlanGpe . Tap . Vxlan @@ -50,6 +51,7 @@ Contexts . Ethernet . Tap . VhostUser +. AfPacket . Vxlan . VxlanGpe . L2 diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesStateReaderFactory.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesStateReaderFactory.java index eaacb135a..8b27c911c 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesStateReaderFactory.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesStateReaderFactory.java @@ -28,6 +28,7 @@ import io.fd.hc2vpp.v3po.interfacesstate.InterfaceRoutingCustomizer; import io.fd.hc2vpp.v3po.interfacesstate.L2Customizer; import io.fd.hc2vpp.v3po.interfacesstate.TapCustomizer; import io.fd.hc2vpp.v3po.interfacesstate.VhostUserCustomizer; +import io.fd.hc2vpp.v3po.interfacesstate.AfPacketCustomizer; import io.fd.hc2vpp.v3po.interfacesstate.VxlanCustomizer; import io.fd.hc2vpp.v3po.interfacesstate.VxlanGpeCustomizer; import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceCacheDumpManager; @@ -52,6 +53,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.SpanBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.Tap; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.VhostUser; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.AfPacket; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.Vxlan; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.VxlanGpe; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.span.state.attributes.MirroredInterfaces; @@ -119,6 +121,9 @@ public final class InterfacesStateReaderFactory implements ReaderFactory { // VhostUser registry.add(new GenericInitReader<>(vppIfcAugId.child(VhostUser.class), new VhostUserCustomizer(jvpp, ifcNamingCtx, ifaceDumpManager))); + // AfPacket + registry.add(new GenericInitReader<>(vppIfcAugId.child(AfPacket.class), + new AfPacketCustomizer(jvpp, ifcNamingCtx, ifaceDumpManager))); // Vxlan registry.add(new GenericInitReader<>(vppIfcAugId.child(Vxlan.class), new VxlanCustomizer(jvpp, ifcNamingCtx, ifaceDumpManager))); diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesWriterFactory.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesWriterFactory.java index 633400438..9cc351eca 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesWriterFactory.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/InterfacesWriterFactory.java @@ -30,6 +30,7 @@ import io.fd.hc2vpp.v3po.interfaces.L2Customizer; import io.fd.hc2vpp.v3po.interfaces.LoopbackCustomizer; import io.fd.hc2vpp.v3po.interfaces.TapCustomizer; import io.fd.hc2vpp.v3po.interfaces.VhostUserCustomizer; +import io.fd.hc2vpp.v3po.interfaces.AfPacketCustomizer; import io.fd.hc2vpp.v3po.interfaces.VxlanCustomizer; import io.fd.hc2vpp.v3po.interfaces.VxlanGpeCustomizer; import io.fd.hc2vpp.v3po.interfaces.pbb.PbbRewriteCustomizer; @@ -53,6 +54,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Span; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Tap; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.VhostUser; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacket; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Vxlan; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.VxlanGpe; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.span.attributes.MirroredInterfaces; @@ -102,6 +104,10 @@ public final class InterfacesWriterFactory implements WriterFactory { final InstanceIdentifier vhostId = VPP_IFC_AUG_ID.child(VhostUser.class); registry.addBefore(new GenericWriter<>(vhostId, new VhostUserCustomizer(jvpp, ifcNamingContext)), ifcId); + // AfPacket(Needs to be executed before Interface customizer) = + final InstanceIdentifier afpacketId = VPP_IFC_AUG_ID.child(AfPacket.class); + registry.addBefore(new GenericWriter<>(afpacketId, new AfPacketCustomizer(jvpp, ifcNamingContext)), + ifcId); // Vxlan(Needs to be executed before Interface customizer) = final InstanceIdentifier vxlanId = VPP_IFC_AUG_ID.child(Vxlan.class); registry.addBefore(new GenericWriter<>(vxlanId, new VxlanCustomizer(jvpp, ifcNamingContext, ifcDisableContext)), @@ -124,8 +130,8 @@ public final class InterfacesWriterFactory implements WriterFactory { registry.addBefore(new GenericWriter<>(greId, new GreCustomizer(jvpp, ifcNamingContext)), ifcId); - - final Set> specificIfcTypes = Sets.newHashSet(vhostId, vxlanId, vxlanGpeId, tapId, loopbackId); + final Set> specificIfcTypes = + Sets.newHashSet(vhostId, afpacketId, vxlanId, vxlanGpeId, tapId, loopbackId); // Ethernet = registry.add(new GenericWriter<>(VPP_IFC_AUG_ID.child(Ethernet.class), diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizer.java new file mode 100644 index 000000000..67d879bd7 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizer.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.v3po.interfaces; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.MacTranslator; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.AfPacketCreate; +import io.fd.vpp.jvpp.core.dto.AfPacketCreateReply; +import io.fd.vpp.jvpp.core.dto.AfPacketDelete; +import io.fd.vpp.jvpp.core.dto.AfPacketDeleteReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.nio.charset.StandardCharsets; +import java.util.concurrent.CompletionStage; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType; +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.yang.types.rev130715.PhysAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacket; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AfPacketCustomizer extends AbstractInterfaceTypeCustomizer + implements MacTranslator, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(AfPacketCustomizer.class); + private final NamingContext interfaceContext; + + public AfPacketCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext) { + super(vppApi); + this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + protected Class getExpectedInterfaceType() { + return org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.AfPacket.class; + } + + @Override + protected final void writeInterface(@Nonnull final InstanceIdentifier id, + @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + final String swIfName = id.firstKeyOf(Interface.class).getName(); + final int swIfIndex = createAfPacketIfc(id, swIfName, dataAfter); + + // Add new interface to our interface context + interfaceContext.addName(swIfIndex, swIfName, writeContext.getMappingContext()); + } + + @Override + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier id, + @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + final String swIfName = id.firstKeyOf(Interface.class).getName(); + deleteAfPacketIfc(id, swIfName, dataBefore); + + // Remove interface from interface context + interfaceContext.removeName(swIfName, writeContext.getMappingContext()); + } + + private int createAfPacketIfc(final InstanceIdentifier id, final String swIfName, final AfPacket afPacket) + throws WriteFailedException { + LOG.debug("Creating af_packet interface {}: {}", swIfName, afPacket); + final CompletionStage createAfPacketIfReplyCompletionStage = + getFutureJVpp().afPacketCreate(getCreateRequest(afPacket)); + final AfPacketCreateReply reply = + getReplyForCreate(createAfPacketIfReplyCompletionStage.toCompletableFuture(), id, afPacket); + LOG.debug("Af_packet interface {} created successfully: {}", swIfName, afPacket); + return reply.swIfIndex; + } + + private AfPacketCreate getCreateRequest(@Nonnull final AfPacket afPacket) { + final AfPacketCreate request = new AfPacketCreate(); + checkArgument(afPacket.getHostInterfaceName() != null, + "host-interface-name is mandatory for af-packet interface"); + request.hostIfName = afPacket.getHostInterfaceName().getBytes(StandardCharsets.UTF_8); + checkArgument(request.hostIfName.length <= 64, + "Interface name for af_packet interface should not be longer than 64 bytes, but was %s", + request.hostIfName.length); + final PhysAddress mac = afPacket.getMac(); + if (mac == null) { + request.useRandomHwAddr = 1; + request.hwAddr = new byte[6]; + } else { + request.useRandomHwAddr = 0; + request.hwAddr = parseMac(mac.getValue()); + } + return request; + } + + private void deleteAfPacketIfc(final InstanceIdentifier id, final String swIfName, + final AfPacket afPacket) throws WriteFailedException { + LOG.debug("Deleting af_packet interface {}: {}", swIfName, afPacket); + final CompletionStage deleteAfPacketIfReplyCompletionStage = + getFutureJVpp().afPacketDelete(getDeleteRequest(afPacket)); + + getReplyForDelete(deleteAfPacketIfReplyCompletionStage.toCompletableFuture(), id); + LOG.debug("Af_packet interface {} deleted successfully: {}", swIfName, afPacket); + } + + private AfPacketDelete getDeleteRequest(@Nonnull final AfPacket afPacket) { + final AfPacketDelete request = new AfPacketDelete(); + request.hostIfName = afPacket.getHostInterfaceName().getBytes(StandardCharsets.UTF_8); + return request; + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizer.java new file mode 100644 index 000000000..132ca7f1a --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizer.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.v3po.interfacesstate; + +import static java.lang.String.format; + +import com.google.common.annotations.VisibleForTesting; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceCacheDumpManager; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; +import io.fd.honeycomb.translate.util.RWUtils; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.honeycomb.translate.util.read.cache.StaticCacheKeyFactory; +import io.fd.vpp.jvpp.core.dto.AfPacketDetails; +import io.fd.vpp.jvpp.core.dto.AfPacketDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.AfPacketDump; +import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +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.state.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceStateAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.AfPacket; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.AfPacketBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AfPacketCustomizer implements InitializingReaderCustomizer, + InterfaceDataTranslator, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(AfPacketCustomizer.class); + private NamingContext interfaceContext; + private final InterfaceCacheDumpManager dumpManager; + private final DumpCacheManager afPacketDumpManager; + + public AfPacketCustomizer(@Nonnull final FutureJVppCore jvpp, + @Nonnull final NamingContext interfaceContext, + @Nonnull final InterfaceCacheDumpManager dumpManager) { + this.interfaceContext = interfaceContext; + this.dumpManager = dumpManager; + this.afPacketDumpManager = + new DumpCacheManager.DumpCacheManagerBuilder() + .withCacheKeyFactory(new StaticCacheKeyFactory(AfPacketCustomizer.class.getName() + "_dump", + AfPacketDetailsReplyDump.class)) + .withExecutor((identifier, params) -> { + final CompletionStage cs = jvpp.afPacketDump(new AfPacketDump()); + return getReplyForRead(cs.toCompletableFuture(), identifier); + }).build(); + } + + @Override + public void merge(@Nonnull Builder parentBuilder, @Nonnull AfPacket readValue) { + ((VppInterfaceStateAugmentationBuilder) parentBuilder).setAfPacket(readValue); + } + + @Nonnull + @Override + public AfPacketBuilder getBuilder(@Nonnull InstanceIdentifier id) { + return new AfPacketBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier id, + @Nonnull final AfPacketBuilder builder, + @Nonnull final ReadContext ctx) throws ReadFailedException { + final InterfaceKey key = id.firstKeyOf(Interface.class); + final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); + final SwInterfaceDetails ifcDetails = dumpManager.getInterfaceDetail(id, ctx, key.getName()); + + if (!isInterfaceOfType( + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.AfPacket.class, + ifcDetails)) { + return; + } + + final AfPacketDetailsReplyDump dump = afPacketDumpManager.getDump(id, ctx.getModificationCache()) + .or(new AfPacketDetailsReplyDump()); + // Relying here that parent InterfaceCustomizer was invoked first to fill in the context with initial ifc mapping + final AfPacketDetails afPacketDetails = dump.afPacketDetails.stream() + .filter(detail -> detail.swIfIndex == index) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException(format("AfPacket interface %s not found", key.getName()))); + LOG.trace("AfPacket interface: {} attributes returned from VPP: {}", key.getName(), afPacketDetails); + + builder.setMac(new PhysAddress(vppPhysAddrToYang(ifcDetails.l2Address))); + builder.setHostInterfaceName(toString(afPacketDetails.hostIfName)); + + LOG.debug("AfPacket interface: {}, id: {} attributes read as: {}", key.getName(), index, builder); + } + + @Nonnull + @Override + public Initialized init( + @Nonnull final InstanceIdentifier id, + @Nonnull final AfPacket readValue, + @Nonnull final ReadContext ctx) { + return Initialized.create(getCfgId(id), + new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacketBuilder() + .setHostInterfaceName(readValue.getHostInterfaceName()) + .setMac(readValue.getMac()) + .build()); + } + + @VisibleForTesting + static InstanceIdentifier getCfgId( + final InstanceIdentifier id) { + return InterfaceCustomizer.getCfgId(RWUtils.cutId(id, Interface.class)) + .augmentation(VppInterfaceAugmentation.class) + .child( + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacket.class); + } +} \ No newline at end of file diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslator.java index 75554d4b7..5a4fbddd4 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslator.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslator.java @@ -34,6 +34,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.re import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType; 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.yang.types.rev130715.Gauge64; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.AfPacket; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.GreTunnel; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.Loopback; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.Tap; @@ -157,6 +158,10 @@ public interface InterfaceDataTranslator extends ByteDataTranslator, JvppReplyCo return VhostUser.class; } + if (interfaceName.startsWith("host-")) { + return AfPacket.class; + } + if (interfaceName.startsWith("loop")) { return Loopback.class; } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizerTest.java new file mode 100644 index 000000000..2834e91bc --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketCustomizerTest.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.v3po.interfaces; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.hc2vpp.common.translate.util.Ipv4Translator; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.AfPacketCreate; +import io.fd.vpp.jvpp.core.dto.AfPacketCreateReply; +import io.fd.vpp.jvpp.core.dto.AfPacketDelete; +import io.fd.vpp.jvpp.core.dto.AfPacketDeleteReply; +import java.nio.charset.StandardCharsets; +import org.junit.Test; +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; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacket; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacketBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AfPacketCustomizerTest extends WriterCustomizerTest implements Ipv4Translator { + + private static final String IFC_TEST_INSTANCE = "ifc-test-instance"; + private static final int IFACE_ID = 1; + private static final String IFACE_NAME = "veth1"; + private static final InstanceIdentifier ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(AfPacket.class); + private AfPacketCustomizer customizer; + + @Override + public void setUpTest() throws Exception { + InterfaceTypeTestUtils.setupWriteContext(writeContext, + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.AfPacket.class); + customizer = new AfPacketCustomizer(api, new NamingContext("generatedInterfaceName", IFC_TEST_INSTANCE)); + + final AfPacketCreateReply createReply = new AfPacketCreateReply(); + createReply.swIfIndex = IFACE_ID; + when(api.afPacketCreate(any())).thenReturn(future(createReply)); + when(api.afPacketDelete(any())).thenReturn(future(new AfPacketDeleteReply())); + } + + @Test + public void testWriteRandomMac() throws WriteFailedException { + final AfPacketCreate expectedCreateRequest = new AfPacketCreate(); + expectedCreateRequest.hostIfName = IFACE_NAME.getBytes(StandardCharsets.UTF_8); + expectedCreateRequest.useRandomHwAddr = 1; + expectedCreateRequest.hwAddr = new byte[6]; + + customizer.writeCurrentAttributes(ID, afPacket(), writeContext); + + verify(api).afPacketCreate(expectedCreateRequest); + verify(mappingContext).put(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE), mapping(IFACE_NAME, IFACE_ID).get()); + } + + @Test + public void testWriteExplicitMac() throws WriteFailedException { + final AfPacket afPacket = afPacket("01:02:03:04:05:06"); + + final AfPacketCreate expectedCreateRequest = new AfPacketCreate(); + expectedCreateRequest.hostIfName = IFACE_NAME.getBytes(StandardCharsets.UTF_8); + expectedCreateRequest.useRandomHwAddr = 0; + expectedCreateRequest.hwAddr = new byte[] {1, 2, 3, 4, 5, 6}; + + customizer.writeCurrentAttributes(ID, afPacket, writeContext); + + verify(api).afPacketCreate(expectedCreateRequest); + verify(mappingContext).put(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE), mapping(IFACE_NAME, IFACE_ID).get()); + } + + @Test + public void testDelete() throws WriteFailedException { + final AfPacket afPacket = afPacket("02:03:04:05:06:07"); + final AfPacketDelete expectedDeleteRequest = new AfPacketDelete(); + expectedDeleteRequest.hostIfName = IFACE_NAME.getBytes(StandardCharsets.UTF_8); + + customizer.deleteCurrentAttributes(ID, afPacket, writeContext); + + verify(api).afPacketDelete(expectedDeleteRequest); + verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE))); + } + + private static AfPacket afPacket() { + return new AfPacketBuilder().setHostInterfaceName(IFACE_NAME).build(); + } + + private static AfPacket afPacket(String mac) { + return new AfPacketBuilder().setHostInterfaceName(IFACE_NAME).setMac(new PhysAddress(mac)).build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizerTest.java new file mode 100644 index 000000000..809c4aec2 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/AfPacketCustomizerTest.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2018 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.v3po.interfacesstate; + +import static io.fd.hc2vpp.v3po.interfacesstate.AfPacketCustomizer.getCfgId; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; +import io.fd.hc2vpp.common.test.util.InterfaceDumpHelper; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceCacheDumpManager; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.AfPacketDetails; +import io.fd.vpp.jvpp.core.dto.AfPacketDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails; +import java.util.Collections; +import org.junit.Test; +import org.mockito.Mock; +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; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceStateAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceStateAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.AfPacket; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces.state._interface.AfPacketBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AfPacketCustomizerTest extends InitializingReaderCustomizerTest + implements InterfaceDumpHelper { + private static final String IFC_CTX_NAME = "ifc-test-instance"; + private static final String IF_NAME = "host-veth1"; + private static final int IF_INDEX = 1; + private static final InstanceIdentifier IID = + InstanceIdentifier.create(InterfacesState.class).child(Interface.class, new InterfaceKey(IF_NAME)) + .augmentation(VppInterfaceStateAugmentation.class).child(AfPacket.class); + + private NamingContext interfaceContext; + + @Mock + private InterfaceCacheDumpManager dumpCacheManager; + + public AfPacketCustomizerTest() { + super(AfPacket.class, VppInterfaceStateAugmentationBuilder.class); + } + + @Override + protected void setUp() throws Exception { + interfaceContext = new NamingContext("generatedInterfaceName", IFC_CTX_NAME); + defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_CTX_NAME); + } + + @Override + protected ReaderCustomizer initCustomizer() { + return new AfPacketCustomizer(api, interfaceContext, dumpCacheManager); + } + + @Test + public void testRead() throws ReadFailedException { + final AfPacketBuilder builder = mock(AfPacketBuilder.class); + when(dumpCacheManager.getInterfaceDetail(IID, ctx, IF_NAME)).thenReturn(ifaceDetails()); + when(api.afPacketDump(any())).thenReturn(future(afPacketReplyDump())); + + getCustomizer().readCurrentAttributes(IID, builder, ctx); + + verify(builder).setMac(new PhysAddress("01:02:03:04:05:06")); + } + + @Test + public void testReadFailed() throws ReadFailedException { + final AfPacketBuilder builder = mock(AfPacketBuilder.class); + when(dumpCacheManager.getInterfaceDetail(IID, ctx, IF_NAME)).thenReturn(null); + + getCustomizer().readCurrentAttributes(IID, builder, ctx); + + verifyZeroInteractions(builder); + } + + @Test + public void testInit() { + final AfPacket operData = new AfPacketBuilder() + .setHostInterfaceName(IF_NAME) + .setMac(new PhysAddress("11:22:33:44:55:66")).build(); + final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacket + cfgData = + new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.AfPacketBuilder() + .setHostInterfaceName(IF_NAME) + .setMac(new PhysAddress("11:22:33:44:55:66")).build(); + invokeInitTest(IID, operData, getCfgId(IID), cfgData); + } + + private SwInterfaceDetails ifaceDetails() { + final SwInterfaceDetails details = new SwInterfaceDetails(); + details.swIfIndex = IF_INDEX; + details.interfaceName = IF_NAME.getBytes(); + details.l2Address = new byte[] {1, 2, 3, 4, 5, 6}; + return details; + } + + private AfPacketDetailsReplyDump afPacketReplyDump() { + final AfPacketDetailsReplyDump reply = new AfPacketDetailsReplyDump(); + final AfPacketDetails details0 = new AfPacketDetails(); + details0.swIfIndex = IF_INDEX; + details0.hostIfName = IF_NAME.getBytes(); + reply.afPacketDetails = Collections.singletonList(details0); + return reply; + } +} \ No newline at end of file diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslatorTest.java index 5595ebb5a..4125513de 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslatorTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/InterfaceDataTranslatorTest.java @@ -32,6 +32,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.re 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; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.AfPacket; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.Tap; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VhostUser; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VxlanGpeTunnel; @@ -64,6 +65,7 @@ public class InterfaceDataTranslatorTest implements InterfaceDataTranslator { assertEquals(VxlanTunnel.class, getInterfaceType("vxlan0")); assertEquals(VxlanGpeTunnel.class, getInterfaceType("vxlan_gpe0")); assertEquals(VhostUser.class, getInterfaceType("VirtualEthernet0/0/0")); + assertEquals(AfPacket.class, getInterfaceType("host-veth0")); assertEquals(EthernetCsmacd.class, getInterfaceType("eth0.0")); assertEquals(EthernetCsmacd.class, getInterfaceType("local0")); } @@ -74,6 +76,7 @@ public class InterfaceDataTranslatorTest implements InterfaceDataTranslator { assertTrue(isInterfaceOfType(VxlanTunnel.class, interfaceDetails("vxlan0"))); assertTrue(isInterfaceOfType(VxlanGpeTunnel.class, interfaceDetails("vxlan_gpe0"))); assertTrue(isInterfaceOfType(VhostUser.class, interfaceDetails("VirtualEthernet0/0/0"))); + assertTrue(isInterfaceOfType(AfPacket.class, interfaceDetails("host-veth0"))); assertTrue(isInterfaceOfType(EthernetCsmacd.class, interfaceDetails("eth0.0"))); assertTrue(isInterfaceOfType(EthernetCsmacd.class, interfaceDetails("local0"))); } -- cgit 1.2.3-korg