diff options
Diffstat (limited to 'v3po')
9 files changed, 432 insertions, 138 deletions
diff --git a/v3po/api/src/main/yang/v3po.yang b/v3po/api/src/main/yang/v3po.yang index 680a81e85..7f093c9fc 100644 --- a/v3po/api/src/main/yang/v3po.yang +++ b/v3po/api/src/main/yang/v3po.yang @@ -142,6 +142,35 @@ module v3po { } } + + typedef span-state { + type enumeration { + enum "receive" { + value "1"; + description + "Receive (Rx) SPAN—The goal of receive (or ingress) SPAN + is to monitor as much as possible all the packets received by the source interface. + A copy of each packet received by the source is sent to the destination port for that SPAN session. + You can monitor a series or range of ingress ports in a SPAN session."; + } + + enum "transmit" { + value "2"; + description + "Transmit (Tx) SPAN—The goal of transmit (or egress) SPAN is to monitor as much as possible all the packets + sent by the source interface after all modification and processing is performed by the switch. + A copy of each packet sent by the source is sent to the destination port for that SPAN session. + The copy is provided after the packet is modified. Monitors a range of egress ports in a SPAN session."; + } + + enum "both" { + value "3"; + description + "In a SPAN session, you can monitor a series or range of ports for both received and sent packets."; + } + } + } + grouping bridge-domain-attributes { leaf flood { type boolean; @@ -477,8 +506,16 @@ module v3po { description "Parameters of the SPAN feature"; container mirrored-interfaces { - leaf-list mirrored-interface { - type if:interface-ref; // todo use interface-state-ref for operational data? + list mirrored-interface { + key "iface-ref"; + leaf iface-ref { + type if:interface-ref; // todo use interface-state-ref for operational data? + } + + leaf state { + type span-state; + mandatory true; + } } } } diff --git a/v3po/postman_rest_collection.json b/v3po/postman_rest_collection.json index e6df2398e..7aa523e6b 100644 --- a/v3po/postman_rest_collection.json +++ b/v3po/postman_rest_collection.json @@ -1770,7 +1770,7 @@ "description": "set span src local0 dst GigabiteEthernet0/8/0", "collectionId": "5bad4634-e5cf-900e-9733-0976aa9bea64", "responses": [], - "rawModeData": "{\r\n \r\n \"span\": {\r\n \t\"mirrored-interfaces\": {\r\n \t\t\"mirrored-interface\": [\"local0\"]\r\n \t}\r\n }\r\n \r\n}" + "rawModeData": "{\r\n \r\n \"span\": {\r\n \t\"mirrored-interfaces\": {\r\n \t\t\"mirrored-interface\": [{\"iface-ref\":\"local0\",\"state\":\"receive\"}]\r\n \t}\r\n }\r\n \r\n}" }, { "id": "ea9e0f3b-ede6-2104-892b-bb8fd72e3d5d", @@ -2256,4 +2256,4 @@ "folder": "ebed4cf3-96db-7ea3-1216-a0802c8f47d3" } ] -}
\ No newline at end of file +} 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 830147cc2..494a17375 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 @@ -16,6 +16,7 @@ package io.fd.hc2vpp.v3po.factory; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import com.google.inject.Inject; import com.google.inject.name.Named; @@ -72,6 +73,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.rev161214.interfaces.state._interface.VxlanGpe; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces.state._interface.acl.Ingress; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.Ip4Acl; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.Ip6Acl; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.L2Acl; @@ -186,8 +188,10 @@ public final class InterfacesStateReaderFactory implements ReaderFactory { final InstanceIdentifier<Span> spanId = vppIfcAugId.child(Span.class); registry.addStructuralReader(spanId, SpanBuilder.class); // MirroredInterfaces - registry.add(new GenericInitReader<>(spanId.child(MirroredInterfaces.class), - new MirroredInterfacesCustomizer(jvpp, ifcNamingCtx))); + registry.subtreeAdd( + ImmutableSet.of(InstanceIdentifier.create(MirroredInterfaces.class).child(MirroredInterface.class)), + new GenericInitReader<>(spanId.child(MirroredInterfaces.class), + new MirroredInterfacesCustomizer(jvpp, ifcNamingCtx))); } private void initPbbRewriteAugmentation(final ModifiableReaderRegistryBuilder registry, 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 94b7f02d7..27a2dd95a 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 @@ -41,7 +41,7 @@ import io.fd.hc2vpp.v3po.interfaces.ip.Ipv4Customizer; import io.fd.hc2vpp.v3po.interfaces.ip.Ipv4NeighbourCustomizer; import io.fd.hc2vpp.v3po.interfaces.ip.Ipv6Customizer; import io.fd.hc2vpp.v3po.interfaces.pbb.PbbRewriteCustomizer; -import io.fd.hc2vpp.v3po.interfaces.span.MirroredInterfacesCustomizer; +import io.fd.hc2vpp.v3po.interfaces.span.MirroredInterfaceCustomizer; import io.fd.hc2vpp.v3po.vppclassifier.VppClassifierContextManager; import io.fd.honeycomb.translate.impl.write.GenericListWriter; import io.fd.honeycomb.translate.impl.write.GenericWriter; @@ -71,6 +71,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.rev161214.interfaces._interface.VxlanGpe; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.acl.Ingress; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.Ip4Acl; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.Ip6Acl; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classfier.acl.rev161214.acl.base.attributes.L2Acl; @@ -198,10 +199,11 @@ public final class InterfacesWriterFactory implements WriterFactory { // Span writers // Mirrored interfaces - final InstanceIdentifier<MirroredInterfaces> mirroredIfcsId = VPP_IFC_AUG_ID + final InstanceIdentifier<MirroredInterface> mirroredIfcId = VPP_IFC_AUG_ID .child(Span.class) - .child(MirroredInterfaces.class); - registry.addAfter(new GenericWriter<>(mirroredIfcsId, new MirroredInterfacesCustomizer(jvpp, ifcNamingContext)), + .child(MirroredInterfaces.class) + .child(MirroredInterface.class); + registry.addAfter(new GenericWriter<>(mirroredIfcId, new MirroredInterfaceCustomizer(jvpp, ifcNamingContext)), ifcId); } diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizer.java new file mode 100644 index 000000000..1d6c5ec92 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizer.java @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2016 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.span; + +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +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.core.dto.SwInterfaceSpanEnableDisable; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +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.v3po.rev161214.SpanState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class MirroredInterfaceCustomizer + extends FutureJVppCustomizer + implements ListWriterCustomizer<MirroredInterface, MirroredInterfaceKey>, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(MirroredInterfaceCustomizer.class); + + private final NamingContext ifcContext; + + public MirroredInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, final NamingContext ifcContext) { + super(futureJVppCore); + this.ifcContext = ifcContext; + } + + private SwInterfaceSpanEnableDisable getSpanAddDelRequest(final int dstId, final Integer srcId, final boolean isAdd, + @Nullable final SpanState state) { + final SwInterfaceSpanEnableDisable spanAddDel = new SwInterfaceSpanEnableDisable(); + spanAddDel.state = (byte) (isAdd + ? state != null + ? state.getIntValue() + : 0 + : 0);// either one of 1(rx),2(tx),3(both) or 0 for disable/delete + spanAddDel.swIfIndexFrom = srcId; + spanAddDel.swIfIndexTo = dstId; + return spanAddDel; + } + + @Override + public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterface> instanceIdentifier, + @Nonnull final MirroredInterface mirroredInterface, + @Nonnull final WriteContext writeContext) + throws WriteFailedException { + final String destinationInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getName(); + final String sourceInterfaceName = mirroredInterface.getIfaceRef(); + final SpanState spanState = mirroredInterface.getState(); + + LOG.debug("Enabling span for source interface {} | destination interface {} | state {}", sourceInterfaceName, + destinationInterfaceName, spanState); + + getReplyForWrite(getFutureJVpp().swInterfaceSpanEnableDisable( + getSpanAddDelRequest( + interfaceId(writeContext, ifcContext, destinationInterfaceName), + interfaceId(writeContext, ifcContext, sourceInterfaceName), + true, + spanState)) + .toCompletableFuture(), instanceIdentifier); + LOG.debug("Span for source interface {} | destination interface {} | state {} successfully enabled", + sourceInterfaceName, destinationInterfaceName, spanState); + } + + + @Override + public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterface> instanceIdentifier, + @Nonnull final MirroredInterface mirroredInterfaceBefore, + @Nonnull final MirroredInterface mirroredInterfaceAfter, + @Nonnull final WriteContext writeContext) throws WriteFailedException { + deleteCurrentAttributes(instanceIdentifier, mirroredInterfaceBefore, writeContext); + writeCurrentAttributes(instanceIdentifier, mirroredInterfaceAfter, writeContext); + } + + @Override + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterface> instanceIdentifier, + @Nonnull final MirroredInterface mirroredInterface, + @Nonnull final WriteContext writeContext) throws WriteFailedException { + final String destinationInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getName(); + final String sourceInterfaceName = mirroredInterface.getIfaceRef(); + LOG.debug("Disabling span for source interface {} | destination interface {} ", sourceInterfaceName, + destinationInterfaceName); + + getReplyForWrite(getFutureJVpp().swInterfaceSpanEnableDisable( + getSpanAddDelRequest( + interfaceId(writeContext, ifcContext, destinationInterfaceName), + interfaceId(writeContext, ifcContext, sourceInterfaceName), + false, + null)) + .toCompletableFuture(), instanceIdentifier); + LOG.debug("Span for source interface {} | destination interface {} successfully disabled", + sourceInterfaceName, destinationInterfaceName); + } + + private static int interfaceId(final WriteContext writeContext, final NamingContext ifcContext, final String name) { + return ifcContext.getIndex(name, writeContext.getMappingContext()); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizer.java deleted file mode 100644 index b7376332d..000000000 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizer.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright (c) 2016 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.span; - -import com.google.common.base.Preconditions; -import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; -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.core.dto.SwInterfaceSpanEnableDisable; -import io.fd.vpp.jvpp.core.dto.SwInterfaceSpanEnableDisableReply; -import io.fd.vpp.jvpp.core.future.FutureJVppCore; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.stream.Collectors; -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.v3po.rev161214.span.attributes.MirroredInterfaces; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public final class MirroredInterfacesCustomizer - extends FutureJVppCustomizer - implements WriterCustomizer<MirroredInterfaces>, JvppReplyConsumer { - - private static final Logger LOG = LoggerFactory.getLogger(MirroredInterfacesCustomizer.class); - - private final NamingContext ifcContext; - - public MirroredInterfacesCustomizer(@Nonnull final FutureJVppCore futureJVppCore, final NamingContext ifcContext) { - super(futureJVppCore); - this.ifcContext = ifcContext; - } - - @Override - public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterfaces> id, - @Nonnull final MirroredInterfaces dataAfter, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - LOG.trace("Writing mirrored interfaces for: {} as: {}", id, dataAfter); - - final int dstId = - ifcContext.getIndex(id.firstKeyOf(Interface.class).getName(), writeContext.getMappingContext()); - - // Collect source IDs - final List<Integer> srcIds = dataAfter.getMirroredInterface().stream() - .map(ifcName -> ifcContext.getIndex(ifcName, writeContext.getMappingContext())) - // Collecting before executing to verify we have all the IDs first, failing fast... - .collect(Collectors.toList()); - - Preconditions.checkArgument(!srcIds.contains(dstId), - "Source and Destination interface for port mirroring detected: %s at %s", dstId, id); - - // Invoke addition for each source ID - final List<CompletableFuture<SwInterfaceSpanEnableDisableReply>> futures = srcIds.stream() - .map(srcId -> getSpanAddDelRequest(dstId, srcId, true)) - .map(request -> getFutureJVpp().swInterfaceSpanEnableDisable(request).toCompletableFuture()) - .collect(Collectors.toList()); - - // Wait for success/exception - for (final CompletableFuture<SwInterfaceSpanEnableDisableReply> future : futures) { - getReplyForWrite(future, id); - } - - LOG.trace("Mirrored interfaces for: {} written successfully", id); - } - - private SwInterfaceSpanEnableDisable getSpanAddDelRequest(final int dstId, final Integer srcId, final boolean isAdd) { - final SwInterfaceSpanEnableDisable spanAddDel = new SwInterfaceSpanEnableDisable(); - spanAddDel.state = (byte) (isAdd ? 3 : 0); // 3 - enable rx & tx : 0 - disabled - spanAddDel.swIfIndexFrom = srcId; - spanAddDel.swIfIndexTo = dstId; - return spanAddDel; - } - - @Override - public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterfaces> id, - @Nonnull final MirroredInterfaces dataBefore, - @Nonnull final MirroredInterfaces dataAfter, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - deleteCurrentAttributes(id, dataBefore, writeContext); - writeCurrentAttributes(id, dataAfter, writeContext); - } - - @Override - public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MirroredInterfaces> id, - @Nonnull final MirroredInterfaces dataBefore, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - LOG.trace("Removing mirrored interfaces for: {} as: {}", id, dataBefore); - - final int dstId = - ifcContext.getIndex(id.firstKeyOf(Interface.class).getName(), writeContext.getMappingContext()); - - final List<Integer> srcIds = dataBefore.getMirroredInterface().stream() - .map(ifcName -> ifcContext.getIndex(ifcName, writeContext.getMappingContext())) - // Collecting before executing to verify we have all the IDs first, failing fast... - .collect(Collectors.toList()); - - final List<CompletableFuture<SwInterfaceSpanEnableDisableReply>> futures = srcIds.stream() - .map(srcId -> getSpanAddDelRequest(dstId, srcId, false)) - .map(request -> getFutureJVpp().swInterfaceSpanEnableDisable(request).toCompletableFuture()) - .collect(Collectors.toList()); - - for (final CompletableFuture<SwInterfaceSpanEnableDisableReply> future : futures) { - getReplyForWrite(future, id); - } - - LOG.trace("Mirrored interfaces for: {} removed successfully", id); - } -} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizer.java index 2396bcfb7..f6aa4982c 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizer.java @@ -32,11 +32,15 @@ import java.util.List; import java.util.stream.Collectors; 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.v3po.rev161214.SpanState; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Span; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces.state._interface.SpanBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfaces; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfacesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceKey; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -79,10 +83,20 @@ public final class MirroredInterfacesCustomizer ctx.getModificationCache().put(getCacheKey(), replyForRead); } - final List<String> mirroredInterfaces = + final List<MirroredInterface> mirroredInterfaces = replyForRead.swInterfaceSpanDetails.stream() .filter(detail -> detail.swIfIndexTo == dstId) - .map(detail -> ifcContext.getName(detail.swIfIndexFrom, ctx.getMappingContext())) + .filter(detail -> detail.state != 0) // filters disabled(we use disabled as delete) + .map(detail -> { + final String interfaceName = + ifcContext.getName(detail.swIfIndexFrom, ctx.getMappingContext()); + return new MirroredInterfaceBuilder() + .setIfaceRef(interfaceName) + .setKey(new MirroredInterfaceKey(interfaceName)) + .setState(SpanState.forValue(detail.state)) + .build(); + } + ) .collect(Collectors.toList()); LOG.debug("Mirrored interfaces for: {} read as: {}", id, mirroredInterfaces); diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizerTest.java new file mode 100644 index 000000000..c7d04f16d --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceCustomizerTest.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2016 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.span; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +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.NamingContext; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSpanEnableDisable; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSpanEnableDisableReply; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +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.opendaylight.params.xml.ns.yang.v3po.rev161214.SpanState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Span; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MirroredInterfaceCustomizerTest extends WriterCustomizerTest { + + private static final String IFACE_NAME = "iface"; + private static final int IFACE_INDEX = 3; + private static final String SRC_IFACE_NAME = "src-iface"; + private static final int SRC_IFACE_INDEX = 5; + + private NamingContext interfaceContext; + private MirroredInterfaceCustomizer customizer; + + private InstanceIdentifier<MirroredInterface> validId; + private MirroredInterface validData; + + @Captor + private ArgumentCaptor<SwInterfaceSpanEnableDisable> requestCaptor; + + public void setUpTest() { + interfaceContext = new NamingContext("iface", "iface-context"); + customizer = new MirroredInterfaceCustomizer(api, interfaceContext); + defineMapping(mappingContext, IFACE_NAME, IFACE_INDEX, "iface-context"); + defineMapping(mappingContext, SRC_IFACE_NAME, SRC_IFACE_INDEX, "iface-context"); + + validId = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(Span.class) + .child(MirroredInterfaces.class) + .child(MirroredInterface.class); + + validData = new MirroredInterfaceBuilder() + .setIfaceRef(SRC_IFACE_NAME) + .setState(SpanState.Receive) + .build(); + + when(api.swInterfaceSpanEnableDisable(any())).thenReturn(future(new SwInterfaceSpanEnableDisableReply())); + } + + @Test + public void writeCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(validId, validData, writeContext); + verify(api, times(1)).swInterfaceSpanEnableDisable(requestCaptor.capture()); + assertCreateRequest(requestCaptor.getValue()); + } + + @Test + public void updateCurrentAttributes() throws Exception { + customizer.updateCurrentAttributes(validId, validData, validData, writeContext); + verify(api, times(2)).swInterfaceSpanEnableDisable(requestCaptor.capture()); + assertDeleteRequest(requestCaptor.getAllValues().get(0)); + assertCreateRequest(requestCaptor.getAllValues().get(1)); + } + + @Test + public void deleteCurrentAttributes() throws Exception { + customizer.deleteCurrentAttributes(validId, validData, writeContext); + verify(api, times(1)).swInterfaceSpanEnableDisable(requestCaptor.capture()); + assertDeleteRequest(requestCaptor.getValue()); + } + + private static void assertCreateRequest(final SwInterfaceSpanEnableDisable createRequest) { + assertNotNull(createRequest); + assertEquals(1, createRequest.state); + assertEquals(IFACE_INDEX, createRequest.swIfIndexTo); + assertEquals(SRC_IFACE_INDEX, createRequest.swIfIndexFrom); + } + + private static void assertDeleteRequest(final SwInterfaceSpanEnableDisable deleteRequest) { + assertNotNull(deleteRequest); + assertEquals(0, deleteRequest.state); + assertEquals(IFACE_INDEX, deleteRequest.swIfIndexTo); + assertEquals(SRC_IFACE_INDEX, deleteRequest.swIfIndexFrom); + } + +}
\ No newline at end of file diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizerTest.java new file mode 100644 index 000000000..296bfc45d --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/span/MirroredInterfacesCustomizerTest.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2016 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.span; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.hasSize; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.ReaderCustomizerTest; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSpanDetails; +import io.fd.vpp.jvpp.core.dto.SwInterfaceSpanDetailsReplyDump; +import java.util.Arrays; +import org.junit.Test; +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.rev161214.SpanState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceStateAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces.state._interface.Span; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces.state._interface.SpanBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.MirroredInterfacesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.span.attributes.mirrored.interfaces.MirroredInterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + + +public class MirroredInterfacesCustomizerTest + extends ReaderCustomizerTest<MirroredInterfaces, MirroredInterfacesBuilder> { + + private static final String IFACE_NAME = "iface"; + + private static final String SRC_IFACE_NAME_1 = "src-one"; + private static final String SRC_IFACE_NAME_2 = "src-two"; + private static final String SRC_IFACE_NAME_3 = "src-three"; + + private static final int IFACE_INDEX = 3; + + private NamingContext interfaceContext; + private InstanceIdentifier<MirroredInterfaces> validId; + private MirroredInterface validData; + + public MirroredInterfacesCustomizerTest() { + super(MirroredInterfaces.class, SpanBuilder.class); + } + + @Override + protected void setUp() throws Exception { + interfaceContext = new NamingContext("iface", "iface-context"); + defineMapping(mappingContext, IFACE_NAME, IFACE_INDEX, "iface-context"); + defineMapping(mappingContext, SRC_IFACE_NAME_1, 1, "iface-context"); + defineMapping(mappingContext, SRC_IFACE_NAME_2, 2, "iface-context"); + defineMapping(mappingContext, SRC_IFACE_NAME_3, 3, "iface-context"); + + validId = InstanceIdentifier.create(InterfacesState.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceStateAugmentation.class).child(Span.class) + .child(MirroredInterfaces.class); + + SwInterfaceSpanDetailsReplyDump dump = new SwInterfaceSpanDetailsReplyDump(); + SwInterfaceSpanDetails detail1 = new SwInterfaceSpanDetails(); + + detail1.swIfIndexTo = IFACE_INDEX; + detail1.swIfIndexFrom = 1; + detail1.state = 1; + + SwInterfaceSpanDetails detail2 = new SwInterfaceSpanDetails(); + + detail2.swIfIndexTo = IFACE_INDEX; + detail2.swIfIndexFrom = 2; + detail2.state = 3; + + SwInterfaceSpanDetails detail3 = new SwInterfaceSpanDetails(); + + detail3.swIfIndexTo = IFACE_INDEX; + detail3.swIfIndexFrom = 3; + detail3.state = 0; + + dump.swInterfaceSpanDetails = Arrays.asList(detail1, detail2, detail3); + + when(api.swInterfaceSpanDump(any())).thenReturn(future(dump)); + } + + @Test + public void readCurrentAttributes() throws Exception { + MirroredInterfacesBuilder builder = new MirroredInterfacesBuilder(); + getCustomizer().readCurrentAttributes(validId, builder, ctx); + + + final MirroredInterfaces data = builder.build(); + // 1,2 should be returned,0 should be filtered out because of disabled state + + assertThat(data.getMirroredInterface(), hasSize(2)); + assertThat(data.getMirroredInterface(), containsInAnyOrder( + mirroredInterface(SRC_IFACE_NAME_1, SpanState.Receive), + mirroredInterface(SRC_IFACE_NAME_2, SpanState.Both))); + } + + private MirroredInterface mirroredInterface(final String ifaceName, final SpanState state) { + return new MirroredInterfaceBuilder() + .setIfaceRef(ifaceName) + .setKey(new MirroredInterfaceKey(ifaceName)) + .setState(state) + .build(); + } + + @Override + protected ReaderCustomizer<MirroredInterfaces, MirroredInterfacesBuilder> initCustomizer() { + return new MirroredInterfacesCustomizer(api, interfaceContext); + } +}
\ No newline at end of file |