diff options
57 files changed, 3094 insertions, 625 deletions
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 3fbdb9f64..4e9f7b9cc 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 @@ -22,20 +22,35 @@ import com.google.inject.name.Named; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.hc2vpp.v3po.DisabledInterfacesManager; import io.fd.hc2vpp.v3po.interfaces.AfPacketCustomizer; +import io.fd.hc2vpp.v3po.interfaces.AfPacketValidator; import io.fd.hc2vpp.v3po.interfaces.EthernetCustomizer; +import io.fd.hc2vpp.v3po.interfaces.EthernetValidator; import io.fd.hc2vpp.v3po.interfaces.GreCustomizer; +import io.fd.hc2vpp.v3po.interfaces.GreValidator; import io.fd.hc2vpp.v3po.interfaces.InterfaceCustomizer; import io.fd.hc2vpp.v3po.interfaces.InterfaceRoutingCustomizer; +import io.fd.hc2vpp.v3po.interfaces.InterfaceRoutingValidator; import io.fd.hc2vpp.v3po.interfaces.InterfaceUnnumberedCustomizer; +import io.fd.hc2vpp.v3po.interfaces.InterfaceUnnumberedValidator; +import io.fd.hc2vpp.v3po.interfaces.InterfaceValidator; import io.fd.hc2vpp.v3po.interfaces.InterfacesStatisticsCustomizer; +import io.fd.hc2vpp.v3po.interfaces.InterfacesStatisticsValidator; import io.fd.hc2vpp.v3po.interfaces.L2Customizer; +import io.fd.hc2vpp.v3po.interfaces.L2Validator; import io.fd.hc2vpp.v3po.interfaces.LoopbackCustomizer; +import io.fd.hc2vpp.v3po.interfaces.LoopbackValidator; import io.fd.hc2vpp.v3po.interfaces.TapV2Customizer; +import io.fd.hc2vpp.v3po.interfaces.TapV2Validator; import io.fd.hc2vpp.v3po.interfaces.VhostUserCustomizer; +import io.fd.hc2vpp.v3po.interfaces.VhostUserValidator; import io.fd.hc2vpp.v3po.interfaces.VxlanCustomizer; import io.fd.hc2vpp.v3po.interfaces.VxlanGpeCustomizer; +import io.fd.hc2vpp.v3po.interfaces.VxlanGpeValidator; +import io.fd.hc2vpp.v3po.interfaces.VxlanValidator; import io.fd.hc2vpp.v3po.interfaces.pbb.PbbRewriteCustomizer; +import io.fd.hc2vpp.v3po.interfaces.pbb.PbbRewriteValidator; import io.fd.hc2vpp.v3po.interfaces.span.MirroredInterfaceCustomizer; +import io.fd.hc2vpp.v3po.interfaces.span.MirroredInterfaceValidator; import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceStatisticsManager; import io.fd.honeycomb.translate.impl.write.GenericListWriter; import io.fd.honeycomb.translate.impl.write.GenericWriter; @@ -98,9 +113,11 @@ public final class InterfacesWriterFactory implements WriterFactory { public void init(final ModifiableWriterRegistryBuilder registry) { // Interfaces registry.add(new GenericWriter<>(IFCS_ID.augmentation(VppInterfacesStatsAugmentation.class) - .child(Statistics.class), new InterfacesStatisticsCustomizer(statisticsManager))); + .child(Statistics.class), new InterfacesStatisticsCustomizer(statisticsManager), + new InterfacesStatisticsValidator(statisticsManager))); // Interface = - registry.add(new GenericListWriter<>(IFC_ID, new InterfaceCustomizer(jvpp, ifcNamingContext))); + registry.add(new GenericListWriter<>(IFC_ID, new InterfaceCustomizer(jvpp, ifcNamingContext), + new InterfaceValidator(ifcNamingContext))); // VppInterfaceAugmentation addVppInterfaceAgmentationWriters(IFC_ID, registry); @@ -111,47 +128,51 @@ public final class InterfacesWriterFactory implements WriterFactory { final ModifiableWriterRegistryBuilder registry) { // VhostUser(Needs to be executed before Interface customizer) = final InstanceIdentifier<VhostUser> vhostId = VPP_IFC_AUG_ID.child(VhostUser.class); - registry.addBefore(new GenericWriter<>(vhostId, new VhostUserCustomizer(jvpp, ifcNamingContext)), - ifcId); + registry.addBefore(new GenericWriter<>(vhostId, new VhostUserCustomizer(jvpp, ifcNamingContext), + new VhostUserValidator(ifcNamingContext)), ifcId); // AfPacket(Needs to be executed before Interface customizer) = final InstanceIdentifier<AfPacket> afpacketId = VPP_IFC_AUG_ID.child(AfPacket.class); - registry.addBefore(new GenericWriter<>(afpacketId, new AfPacketCustomizer(jvpp, ifcNamingContext)), - ifcId); + registry.addBefore(new GenericWriter<>(afpacketId, new AfPacketCustomizer(jvpp, ifcNamingContext), + new AfPacketValidator(ifcNamingContext)), ifcId); // Vxlan(Needs to be executed before Interface customizer) = final InstanceIdentifier<Vxlan> vxlanId = VPP_IFC_AUG_ID.child(Vxlan.class); - registry.addBefore(new GenericWriter<>(vxlanId, new VxlanCustomizer(jvpp, ifcNamingContext, ifcDisableContext)), + registry.addBefore(new GenericWriter<>(vxlanId, new VxlanCustomizer(jvpp, ifcNamingContext, ifcDisableContext), + new VxlanValidator(ifcNamingContext, ifcDisableContext)), ifcId); // VxlanGpe(Needs to be executed before Interface customizer) = final InstanceIdentifier<VxlanGpe> vxlanGpeId = VPP_IFC_AUG_ID.child(VxlanGpe.class); registry.addBefore(new GenericWriter<>(vxlanGpeId, - new VxlanGpeCustomizer(jvpp, ifcNamingContext, ifcDisableContext)), ifcId); + new VxlanGpeCustomizer(jvpp, ifcNamingContext, ifcDisableContext), + new VxlanGpeValidator(ifcNamingContext, ifcDisableContext)), ifcId); // TapV2(Needs to be executed before Interface customizer) = final InstanceIdentifier<TapV2> tapV2Id = VPP_IFC_AUG_ID.child(TapV2.class); - registry.addBefore(new GenericWriter<>(tapV2Id, new TapV2Customizer(jvpp, ifcNamingContext)), - ifcId); + registry.addBefore(new GenericWriter<>(tapV2Id, new TapV2Customizer(jvpp, ifcNamingContext), + new TapV2Validator(ifcNamingContext)), ifcId); // Loopback(Needs to be executed before Interface customizer) = final InstanceIdentifier<Loopback> loopbackId = VPP_IFC_AUG_ID.child(Loopback.class); - registry.addBefore(new GenericWriter<>(loopbackId, new LoopbackCustomizer(jvpp, ifcNamingContext)), - ifcId); + registry.addBefore(new GenericWriter<>(loopbackId, new LoopbackCustomizer(jvpp, ifcNamingContext), + new LoopbackValidator(ifcNamingContext)), ifcId); // Gre(Needs to be executed before Interface customizer) = final InstanceIdentifier<Gre> greId = VPP_IFC_AUG_ID.child(Gre.class); - registry.addBefore(new GenericWriter<>(greId, new GreCustomizer(jvpp, ifcNamingContext)), - ifcId); + registry.addBefore(new GenericWriter<>(greId, new GreCustomizer(jvpp, ifcNamingContext), + new GreValidator(ifcNamingContext)), ifcId); final Set<InstanceIdentifier<?>> specificIfcTypes = Sets.newHashSet(vhostId, afpacketId, vxlanId, vxlanGpeId, tapV2Id, loopbackId); // Ethernet = registry.add(new GenericWriter<>(VPP_IFC_AUG_ID.child(Ethernet.class), - new EthernetCustomizer(jvpp, ifcNamingContext))); + new EthernetCustomizer(jvpp, ifcNamingContext), new EthernetValidator(ifcNamingContext))); // Routing(Execute only after specific interface customizers) = registry.addAfter( new GenericWriter<>(VPP_IFC_AUG_ID.child(Routing.class), - new InterfaceRoutingCustomizer(jvpp, ifcNamingContext)), + new InterfaceRoutingCustomizer(jvpp, ifcNamingContext), + new InterfaceRoutingValidator(ifcNamingContext)), specificIfcTypes); // L2(Execute only after subinterface (and all other ifc types) = - registry.addAfter(new GenericWriter<>(L2_ID, new L2Customizer(jvpp, ifcNamingContext, bdNamingContext)), + registry.addAfter(new GenericWriter<>(L2_ID, new L2Customizer(jvpp, ifcNamingContext, bdNamingContext), + new L2Validator(ifcNamingContext, bdNamingContext)), SubinterfaceAugmentationWriterFactory.SUB_IFC_ID); // Span writers @@ -161,13 +182,15 @@ public final class InterfacesWriterFactory implements WriterFactory { .child(MirroredInterfaces.class) .child(MirroredInterface.class); registry.addAfter(new GenericWriter<>(mirroredIfcId, new MirroredInterfaceCustomizer(jvpp, ifcNamingContext, - id -> id.firstKeyOf(Interface.class).getName())), ifcId); + id -> id.firstKeyOf(Interface.class).getName()), + new MirroredInterfaceValidator(ifcNamingContext, id -> id.firstKeyOf(Interface.class).getName())), + ifcId); // Unnumbered = final InstanceIdentifier<Unnumbered> unnumberedId = IFC_ID.augmentation(InterfaceUnnumberedAugmentation.class).child(Unnumbered.class); - registry.addAfter(new GenericWriter<>(unnumberedId, new InterfaceUnnumberedCustomizer(jvpp, ifcNamingContext)), - ifcId); + registry.addAfter(new GenericWriter<>(unnumberedId, new InterfaceUnnumberedCustomizer(jvpp, ifcNamingContext), + new InterfaceUnnumberedValidator(ifcNamingContext)), ifcId); } private void addPbbAugmentationWriters(final InstanceIdentifier<Interface> ifcId, @@ -175,6 +198,7 @@ public final class InterfacesWriterFactory implements WriterFactory { final InstanceIdentifier<PbbRewrite> pbbRewriteId = ifcId.augmentation(PbbRewriteInterfaceAugmentation.class).child(PbbRewrite.class); - registry.add(new GenericWriter<>(pbbRewriteId, new PbbRewriteCustomizer(jvpp, ifcNamingContext))); + registry.add(new GenericWriter<>(pbbRewriteId, new PbbRewriteCustomizer(jvpp, ifcNamingContext), + new PbbRewriteValidator(ifcNamingContext))); } } diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/SubinterfaceAugmentationWriterFactory.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/SubinterfaceAugmentationWriterFactory.java index cdcd07000..237eab57a 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/SubinterfaceAugmentationWriterFactory.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/factory/SubinterfaceAugmentationWriterFactory.java @@ -21,10 +21,15 @@ import com.google.inject.Inject; import com.google.inject.name.Named; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.hc2vpp.v3po.interfaces.RewriteCustomizer; +import io.fd.hc2vpp.v3po.interfaces.RewriteValidator; import io.fd.hc2vpp.v3po.interfaces.SubInterfaceCustomizer; import io.fd.hc2vpp.v3po.interfaces.SubInterfaceL2Customizer; +import io.fd.hc2vpp.v3po.interfaces.SubInterfaceL2Validator; import io.fd.hc2vpp.v3po.interfaces.SubInterfaceRoutingCustomizer; +import io.fd.hc2vpp.v3po.interfaces.SubInterfaceRoutingValidator; import io.fd.hc2vpp.v3po.interfaces.SubInterfaceUnnumberedCustomizer; +import io.fd.hc2vpp.v3po.interfaces.SubInterfaceUnnumberedValidator; +import io.fd.hc2vpp.v3po.interfaces.SubInterfaceValidator; import io.fd.hc2vpp.v3po.interfaces.span.MirroredInterfaceCustomizer; import io.fd.hc2vpp.v3po.util.SubInterfaceUtils; import io.fd.honeycomb.translate.impl.write.GenericListWriter; @@ -59,11 +64,11 @@ public final class SubinterfaceAugmentationWriterFactory implements WriterFactor private final NamingContext bdContext; public static final InstanceIdentifier<SubinterfaceAugmentation> SUB_IFC_AUG_ID = - InterfacesWriterFactory.IFC_ID.augmentation(SubinterfaceAugmentation.class); + InterfacesWriterFactory.IFC_ID.augmentation(SubinterfaceAugmentation.class); public static final InstanceIdentifier<SubInterface> SUB_IFC_ID = - SUB_IFC_AUG_ID.child(SubInterfaces.class).child(SubInterface.class); + SUB_IFC_AUG_ID.child(SubInterfaces.class).child(SubInterface.class); public static final InstanceIdentifier<L2> L2_ID = SUB_IFC_ID.child( - L2.class); + L2.class); @Inject public SubinterfaceAugmentationWriterFactory(final FutureJVppCore jvpp, @@ -79,31 +84,35 @@ public final class SubinterfaceAugmentationWriterFactory implements WriterFactor // Subinterfaces // Subinterface(Handle only after all interface related stuff gets processed) = registry.subtreeAddAfter( - // TODO HONEYCOMB-188 this customizer covers quite a lot of complex child nodes (maybe refactor ?) - Sets.newHashSet( - InstanceIdentifier.create(SubInterface.class).child(Tags.class), - InstanceIdentifier.create(SubInterface.class).child(Tags.class).child(Tag.class), - InstanceIdentifier.create(SubInterface.class).child(Tags.class).child(Tag.class).child( - Dot1qTag.class), - InstanceIdentifier.create(SubInterface.class).child(Match.class), - InstanceIdentifier.create(SubInterface.class).child(Match.class).child(VlanTagged.class)), - new GenericListWriter<>(SUB_IFC_ID, new SubInterfaceCustomizer(jvpp, ifcContext)), - InterfacesWriterFactory.IFC_ID); + // TODO HONEYCOMB-188 this customizer covers quite a lot of complex child nodes (maybe refactor ?) + Sets.newHashSet( + InstanceIdentifier.create(SubInterface.class).child(Tags.class), + InstanceIdentifier.create(SubInterface.class).child(Tags.class).child(Tag.class), + InstanceIdentifier.create(SubInterface.class).child(Tags.class).child(Tag.class).child( + Dot1qTag.class), + InstanceIdentifier.create(SubInterface.class).child(Match.class), + InstanceIdentifier.create(SubInterface.class).child(Match.class).child(VlanTagged.class)), + new GenericListWriter<>(SUB_IFC_ID, new SubInterfaceCustomizer(jvpp, ifcContext), + new SubInterfaceValidator(ifcContext)), + InterfacesWriterFactory.IFC_ID); // L2 = - registry.addAfter(new GenericWriter<>(L2_ID, new SubInterfaceL2Customizer(jvpp, ifcContext, bdContext)), - SUB_IFC_ID); + registry.addAfter(new GenericWriter<>(L2_ID, new SubInterfaceL2Customizer(jvpp, ifcContext, bdContext), + new SubInterfaceL2Validator(ifcContext, bdContext)), + SUB_IFC_ID); // Rewrite(also handles pushTags + pushTags/dot1qtag) = final InstanceIdentifier<Rewrite> rewriteId = L2_ID.child(Rewrite.class); registry.subtreeAddAfter( - Sets.newHashSet( - InstanceIdentifier.create(Rewrite.class).child(PushTags.class), - InstanceIdentifier.create(Rewrite.class).child(PushTags.class) - .child( - org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.dot1q.tag.Dot1qTag.class)), - new GenericWriter<>(rewriteId, new RewriteCustomizer(jvpp, ifcContext)), - L2_ID); + Sets.newHashSet( + InstanceIdentifier.create(Rewrite.class).child(PushTags.class), + InstanceIdentifier.create(Rewrite.class).child(PushTags.class) + .child( + org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.dot1q.tag.Dot1qTag.class)), + new GenericWriter<>(rewriteId, new RewriteCustomizer(jvpp, ifcContext), + new RewriteValidator(ifcContext)), + L2_ID); final InstanceIdentifier<Routing> routingId = SUB_IFC_ID.child(Routing.class); - registry.add(new GenericWriter<>(routingId, new SubInterfaceRoutingCustomizer(jvpp, ifcContext))); + registry.add(new GenericWriter<>(routingId, new SubInterfaceRoutingCustomizer(jvpp, ifcContext), + new SubInterfaceRoutingValidator(ifcContext))); final InstanceIdentifier<MirroredInterface> mirroredId = SUB_IFC_ID.augmentation(VppSubinterfaceSpanAugmentation.class) @@ -116,8 +125,9 @@ public final class SubinterfaceAugmentationWriterFactory implements WriterFactor // Unnumbered = final InstanceIdentifier<Unnumbered> unnumberedId = - SUB_IFC_ID.augmentation(SubinterfaceUnnumberedAugmentation.class).child(Unnumbered.class); - registry.addAfter(new GenericWriter<>(unnumberedId, new SubInterfaceUnnumberedCustomizer(jvpp, ifcContext)), - SUB_IFC_ID); + SUB_IFC_ID.augmentation(SubinterfaceUnnumberedAugmentation.class).child(Unnumbered.class); + registry.addAfter(new GenericWriter<>(unnumberedId, new SubInterfaceUnnumberedCustomizer(jvpp, ifcContext), + new SubInterfaceUnnumberedValidator(ifcContext)), + SUB_IFC_ID); } } 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 index ecb4f8c79..ea4220acd 100644 --- 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 @@ -16,9 +16,6 @@ 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; @@ -49,7 +46,7 @@ public class AfPacketCustomizer extends AbstractInterfaceTypeCustomizer<AfPacket public AfPacketCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext) { super(vppApi); - this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null"); + this.interfaceContext = interfaceContext; } @Override @@ -92,12 +89,7 @@ public class AfPacketCustomizer extends AbstractInterfaceTypeCustomizer<AfPacket 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; diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidator.java new file mode 100644 index 000000000..f76922cd0 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidator.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import java.nio.charset.StandardCharsets; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.AfPacket; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AfPacketValidator implements Validator<AfPacket> { + + public AfPacketValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter, + @Nonnull final WriteContext writeContext) + throws CreateValidationFailedException { + try { + validateAfPacket(dataAfter); + } catch (Exception e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, + @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext) + throws UpdateValidationFailedException { + try { + validateAfPacket(dataAfter); + } catch (Exception e) { + throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, + @Nonnull final WriteContext writeContext) + throws DeleteValidationFailedException { + try { + validateAfPacket(dataBefore); + } catch (Exception e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private void validateAfPacket(final AfPacket data) { + checkNotNull(data.getHostInterfaceName(), "host-interface-name is mandatory for af-packet interface"); + byte[] hostIfName = data.getHostInterfaceName().getBytes(StandardCharsets.UTF_8); + checkArgument(hostIfName.length <= 64, + "Interface name for af_packet interface should not be longer than 64 bytes, but was %s", + hostIfName.length); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidator.java new file mode 100644 index 000000000..e8fa32a17 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidator.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Ethernet; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class EthernetValidator implements Validator<Ethernet> { + + public EthernetValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + checkNotNull(dataAfter.getMtu(), "MTU cannot be null"); + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, + @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + checkNotNull(dataAfter.getMtu(), "MTU cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizer.java index 3496fdd88..b13388102 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizer.java @@ -16,8 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkArgument; - import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer; import io.fd.hc2vpp.common.translate.util.AddressTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -125,15 +123,7 @@ public class GreCustomizer extends AbstractInterfaceTypeCustomizer<Gre> implemen } private boolean isIpv6(final Gre gre) { - if (gre.getSrc().getIpv4AddressNoZone() == null) { - checkArgument(gre.getDst().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", gre.getSrc(), - gre.getDst()); - return true; - } else { - checkArgument(gre.getDst().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", gre.getSrc(), - gre.getDst()); - return false; - } + return gre.getSrc().getIpv4AddressNoZone() == null; } private void deleteGreTunnel(final InstanceIdentifier<Gre> id, final String swIfName, final Gre gre, diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreValidator.java new file mode 100644 index 000000000..9376ab87d --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/GreValidator.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Gre; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GreValidator implements Validator<Gre> { + + public GreValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + try { + validateGre(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + try { + validateGre(dataBefore); + } catch (Exception e) { + throw new DataValidationFailedException.DeleteValidationFailedException(id, e); + } + } + + private void validateGre(final Gre data) { + checkNotNull(data.getOuterFibId(), "Outer Fib ID cannot be null"); + checkNotNull(data.getSrc(), "Source cannot be null"); + checkNotNull(data.getDst(), "Destination cannot be null"); + if (data.getSrc().getIpv4AddressNoZone() == null) { + checkArgument(data.getDst().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getSrc(), + data.getDst()); + } else { + checkArgument(data.getDst().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getSrc(), + data.getDst()); + } + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizer.java index 30885fc1e..e498e0cae 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizer.java @@ -16,22 +16,14 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkState; - -import java.util.Optional; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.honeycomb.translate.spi.write.WriterCustomizer; -import io.fd.honeycomb.translate.util.RWUtils; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.jvpp.core.future.FutureJVppCore; -import java.util.List; import javax.annotation.Nonnull; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Routing; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv6; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class InterfaceRoutingCustomizer extends RoutingCustomizer @@ -46,10 +38,6 @@ public class InterfaceRoutingCustomizer extends RoutingCustomizer public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { - - checkState(isAddressNotPresentForInterface(id, writeContext, true), - "Cannot change routing configuration, if address is present for interface"); - final String ifName = id.firstKeyOf(Interface.class).getName(); setRouting(id, ifName, dataAfter, writeContext); } @@ -59,9 +47,6 @@ public class InterfaceRoutingCustomizer extends RoutingCustomizer @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { - checkState(isAddressNotPresentForInterface(id, writeContext, true), - "Cannot change routing configuration, if address is present for interface"); - final String ifName = id.firstKeyOf(Interface.class).getName(); setRouting(id, ifName, dataAfter, writeContext); } @@ -70,35 +55,7 @@ public class InterfaceRoutingCustomizer extends RoutingCustomizer public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { - checkState(isAddressNotPresentForInterface(id, writeContext, false), - "Cannot change routing configuration, if address is present for interface"); - final String ifName = id.firstKeyOf(Interface.class).getName(); disableRouting(id, ifName, writeContext); } - - /** - * Returns true if interface does not have v4/v6 addresses configured - */ - private boolean isAddressNotPresentForInterface(@Nonnull final InstanceIdentifier<Routing> id, - @Nonnull final WriteContext ctx, - boolean checkBefore) { - final Optional<Interface> interfaceData = checkBefore - ? ctx.readBefore(RWUtils.cutId(id, Interface.class)) - : ctx.readAfter(RWUtils.cutId(id, Interface.class)); - - if (interfaceData.isPresent()) { - final java.util.Optional<Interface1> augData = java.util.Optional.of(interfaceData.get()) - .map(iface -> iface.augmentation(Interface1.class)); - - final boolean v4NotPresent = - augData.map(Interface1::getIpv4).map(Ipv4::getAddress).map(List::isEmpty).orElse(true); - - final boolean v6NotPresent = - augData.map(Interface1::getIpv6).map(Ipv6::getAddress).map(List::isEmpty).orElse(true); - - return v4NotPresent && v6NotPresent; - } - return true; - } } diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidator.java new file mode 100644 index 000000000..011772600 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidator.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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 static com.google.common.base.Preconditions.checkState; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.util.RWUtils; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.List; +import java.util.Optional; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.RoutingBaseAttributes; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Routing; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv6; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceRoutingValidator implements Validator<Routing> { + + public InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, + @Nonnull final WriteContext writeContext) + throws CreateValidationFailedException { + try { + checkVrfIds(dataAfter); + checkInterfaceAddressConf(id, writeContext, true); + } catch (Exception e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, + @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) + throws UpdateValidationFailedException { + try { + checkVrfIds(dataAfter); + checkInterfaceAddressConf(id, writeContext, true); + } catch (Exception e) { + throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, + @Nonnull final WriteContext writeContext) + throws DeleteValidationFailedException { + try { + checkVrfIds(dataBefore); + checkInterfaceAddressConf(id, writeContext, false); + } catch (Exception e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private void checkVrfIds(final RoutingBaseAttributes data) { + checkArgument(data.getIpv4VrfId() != null || data.getIpv6VrfId() != null, "No vrf-id given"); + } + + private void checkInterfaceAddressConf(@Nonnull final InstanceIdentifier<Routing> id, + @Nonnull final WriteContext ctx, + boolean checkBefore) { + checkState(isAddressNotPresentForInterface(id, ctx, checkBefore), + "Cannot change routing configuration, if address is present for interface"); + } + + /** + * Returns true if interface does not have v4/v6 addresses configured + */ + private boolean isAddressNotPresentForInterface(@Nonnull final InstanceIdentifier<Routing> id, + @Nonnull final WriteContext ctx, + boolean checkBefore) { + final Optional<Interface> interfaceData = checkBefore + ? ctx.readBefore(RWUtils.cutId(id, Interface.class)) + : ctx.readAfter(RWUtils.cutId(id, Interface.class)); + + if (interfaceData.isPresent()) { + final java.util.Optional<Interface1> augData = java.util.Optional.of(interfaceData.get()) + .map(iface -> iface.augmentation(Interface1.class)); + + final boolean v4NotPresent = + augData.map(Interface1::getIpv4).map(Ipv4::getAddress).map(List::isEmpty).orElse(true); + + final boolean v6NotPresent = + augData.map(Interface1::getIpv6).map(Ipv6::getAddress).map(List::isEmpty).orElse(true); + + return v4NotPresent && v6NotPresent; + } + return true; + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidator.java new file mode 100644 index 000000000..0120582d1 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.Unnumbered; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceUnnumberedValidator implements Validator<Unnumbered> { + + public InterfaceUnnumberedValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + checkNotNull(dataAfter.getUse(), "Use cannot be null"); + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, + @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + checkNotNull(dataAfter.getUse(), "Use cannot be null"); + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + checkNotNull(dataBefore.getUse(), "Use cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidator.java new file mode 100644 index 000000000..3e6ed638e --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidator.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceValidator implements Validator<Interface> { + + public InterfaceValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, + @Nonnull final WriteContext writeContext) + throws CreateValidationFailedException { + try { + checkInterface(dataAfter); + } catch (Exception e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, + @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) + throws UpdateValidationFailedException { + try { + checkInterface(dataAfter); + } catch (Exception e) { + throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, + @Nonnull final WriteContext writeContext) + throws DeleteValidationFailedException { + try { + checkInterface(dataBefore); + } catch (Exception e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private void checkInterface(final Interface data) { + checkNotNull(data.isEnabled(), "Enabled tag cannot be null"); + checkNotNull(data.getName(), "Name cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsCustomizer.java index b67eccda3..e7ef14dc4 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsCustomizer.java @@ -16,8 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkNotNull; - import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceStatisticsManager; import io.fd.honeycomb.translate.spi.write.WriterCustomizer; import io.fd.honeycomb.translate.write.WriteContext; @@ -26,13 +24,12 @@ import javax.annotation.Nonnull; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces.Statistics; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -public class InterfacesStatisticsCustomizer implements - WriterCustomizer<Statistics> { +public class InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { private final InterfaceStatisticsManager statisticsManager; public InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager) { - this.statisticsManager = checkNotNull(statisticsManager, "Statistics Collection Manager should not be null"); + this.statisticsManager = statisticsManager; } @Override diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsValidator.java new file mode 100644 index 000000000..00c58b5fc --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/InterfacesStatisticsValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.v3po.interfacesstate.cache.InterfaceStatisticsManager; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces.Statistics; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfacesStatisticsValidator implements Validator<Statistics> { + + public InterfacesStatisticsValidator(final InterfaceStatisticsManager statisticsManager) { + checkNotNull(statisticsManager, "Statistics Collection Manager should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, + @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/L2Validator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/L2Validator.java new file mode 100644 index 000000000..3c59bd98d --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/L2Validator.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.L2; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class L2Validator implements Validator<L2> { + + public L2Validator(final NamingContext interfaceContext, + final NamingContext bridgeDomainContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + checkNotNull(bridgeDomainContext, "bridgeDomainContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, + @Nonnull final L2 dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/LoopbackValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/LoopbackValidator.java new file mode 100644 index 000000000..57f1eb108 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/LoopbackValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Loopback; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class LoopbackValidator implements Validator<Loopback> { + + public LoopbackValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataBefore, + @Nonnull final Loopback dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizer.java index 2c350eb15..169dd9958 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizer.java @@ -16,7 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import com.google.common.base.Preconditions; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -55,7 +54,7 @@ public class RewriteCustomizer extends FutureJVppCustomizer public RewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext) { super(futureJVppCore); - this.interfaceContext = Preconditions.checkNotNull(interfaceContext, "interfaceContext should not be null"); + this.interfaceContext = interfaceContext; } @Override diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteValidator.java new file mode 100644 index 000000000..e867a10f4 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/RewriteValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.rewrite.attributes.Rewrite; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class RewriteValidator implements Validator<Rewrite> { + + public RewriteValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, + @Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizer.java index d3688d8ea..881447543 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizer.java @@ -20,7 +20,6 @@ import static com.google.common.base.Preconditions.checkState; import static io.fd.hc2vpp.v3po.util.SubInterfaceUtils.getNumberOfTags; import static io.fd.hc2vpp.v3po.util.SubInterfaceUtils.getSubInterfaceName; -import com.google.common.base.Preconditions; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -65,7 +64,7 @@ public class SubInterfaceCustomizer extends FutureJVppCustomizer public SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext) { super(futureJVppCore); - this.interfaceContext = Preconditions.checkNotNull(interfaceContext, "interfaceContext should not be null"); + this.interfaceContext = interfaceContext; } @Override @@ -116,8 +115,8 @@ public class SubInterfaceCustomizer extends FutureJVppCustomizer // TODO HONEYCOMB-183 match should be mandatory final MatchType matchType = subInterface.getMatch().getMatchType(); request.exactMatch = booleanToByte( - matchType instanceof VlanTagged - && ((VlanTagged) matchType).getVlanTagged().isMatchExactTags() + matchType instanceof VlanTagged + && ((VlanTagged) matchType).getVlanTagged().isMatchExactTags() ); request.defaultSub = booleanToByte(matchType instanceof Default); if (numberOfTags > 0) { diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2Validator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2Validator.java new file mode 100644 index 000000000..3a2ed5d0c --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2Validator.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.l2.config.attributes.L2; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceL2Validator implements Validator<L2> { + + public SubInterfaceL2Validator(final NamingContext interfaceContext, + final NamingContext bridgeDomainContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + checkNotNull(bridgeDomainContext, "bridgeDomainContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, + @Nonnull final L2 dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizer.java index fbaccfa1c..951944a57 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizer.java @@ -16,21 +16,14 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkState; import static io.fd.hc2vpp.v3po.util.SubInterfaceUtils.subInterfaceFullNameConfig; -import java.util.Optional; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.honeycomb.translate.spi.write.WriterCustomizer; -import io.fd.honeycomb.translate.util.RWUtils; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.jvpp.core.future.FutureJVppCore; -import java.util.List; import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.Ipv4; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.Ipv6; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.Routing; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -45,8 +38,6 @@ public class SubInterfaceRoutingCustomizer extends RoutingCustomizer implements public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext) throws WriteFailedException { - checkState(isAddressNotPresentForSubInterface(instanceIdentifier, writeContext, true), - "Cannot change routing configuration, if address is present for sub-interface"); setRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), routing, writeContext); } @@ -54,8 +45,6 @@ public class SubInterfaceRoutingCustomizer extends RoutingCustomizer implements public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final Routing d1, @Nonnull final WriteContext writeContext) throws WriteFailedException { - checkState(isAddressNotPresentForSubInterface(instanceIdentifier, writeContext, true), - "Cannot change routing configuration, if address is present for sub-interface"); setRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), routing, writeContext); } @@ -63,35 +52,6 @@ public class SubInterfaceRoutingCustomizer extends RoutingCustomizer implements public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext) throws WriteFailedException { - checkState(isAddressNotPresentForSubInterface(instanceIdentifier, writeContext, false), - "Cannot change routing configuration, if address is present for sub-interface"); disableRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), writeContext); } - - /** - * Returns true if interface does not have v4/v6 addresses configured - */ - private boolean isAddressNotPresentForSubInterface(@Nonnull final InstanceIdentifier<Routing> id, - @Nonnull final WriteContext ctx, - boolean checkBefore) { - final Optional<SubInterface> subInterfaceData = checkBefore - ? - ctx.readBefore(RWUtils.cutId(id, SubInterface.class)) - : - ctx.readAfter(RWUtils.cutId(id, SubInterface.class)); - - if (subInterfaceData.isPresent()) { - final SubInterface subInterface = subInterfaceData.get(); - - final boolean v4NotPresent = - java.util.Optional.ofNullable(subInterface.getIpv4()).map(Ipv4::getAddress).map(List::isEmpty) - .orElse(true); - - final boolean v6NotPresent = - java.util.Optional.ofNullable(subInterface.getIpv6()).map(Ipv6::getAddress).map(List::isEmpty) - .orElse(true); - return v4NotPresent && v6NotPresent; - } - return true; - } } diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidator.java new file mode 100644 index 000000000..85b864d14 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidator.java @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.util.RWUtils; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.List; +import java.util.Optional; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.Ipv4; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.Ipv6; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.Routing; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceRoutingValidator implements Validator<Routing> { + + public SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, + @Nonnull final WriteContext writeContext) + throws CreateValidationFailedException { + try { + checkInterfaceAddressConf(id, writeContext, true); + } catch (Exception e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, + @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) + throws UpdateValidationFailedException { + try { + checkInterfaceAddressConf(id, writeContext, true); + } catch (Exception e) { + throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, + @Nonnull final WriteContext writeContext) + throws DeleteValidationFailedException { + try { + checkInterfaceAddressConf(id, writeContext, false); + } catch (Exception e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private void checkInterfaceAddressConf(@Nonnull final InstanceIdentifier<Routing> id, + @Nonnull final WriteContext ctx, + boolean checkBefore) { + checkState(isAddressNotPresentForSubInterface(id, ctx, checkBefore), + "Cannot change routing configuration, if address is present for sub-interface"); + } + + /** + * Returns true if interface does not have v4/v6 addresses configured + */ + private boolean isAddressNotPresentForSubInterface(@Nonnull final InstanceIdentifier<Routing> id, + @Nonnull final WriteContext ctx, + boolean checkBefore) { + final Optional<SubInterface> subInterfaceData = checkBefore + ? + ctx.readBefore(RWUtils.cutId(id, SubInterface.class)) + : + ctx.readAfter(RWUtils.cutId(id, SubInterface.class)); + + if (subInterfaceData.isPresent()) { + final SubInterface subInterface = subInterfaceData.get(); + + final boolean v4NotPresent = + java.util.Optional.ofNullable(subInterface.getIpv4()).map(Ipv4::getAddress).map(List::isEmpty) + .orElse(true); + + final boolean v6NotPresent = + java.util.Optional.ofNullable(subInterface.getIpv6()).map(Ipv6::getAddress).map(List::isEmpty) + .orElse(true); + return v4NotPresent && v6NotPresent; + } + return true; + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidator.java new file mode 100644 index 000000000..8cc565c5a --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.Unnumbered; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceUnnumberedValidator implements Validator<Unnumbered> { + + public SubInterfaceUnnumberedValidator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + checkNotNull(dataAfter.getUse()); + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, + @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + checkNotNull(dataAfter.getUse()); + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + checkNotNull(dataBefore.getUse()); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidator.java new file mode 100644 index 000000000..0f8a86232 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidator.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceValidator implements Validator<SubInterface> { + + public SubInterfaceValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + try { + checkSubInterface(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<SubInterface> id, + @Nonnull final SubInterface dataBefore, + @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + try { + checkSubInterface(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + private void checkSubInterface(final SubInterface data) { + checkNotNull(data.getIdentifier(), "Identifier cannot be null"); + checkNotNull(data.getMatch(), "Match cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/TapV2Validator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/TapV2Validator.java new file mode 100644 index 000000000..0d3c3efa6 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/TapV2Validator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.TapV2; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class TapV2Validator implements Validator<TapV2> { + + public TapV2Validator(final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore, + @Nonnull final TapV2 dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + // there is nothing to validate yet + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizer.java index c009e712c..61ce5468c 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizer.java @@ -16,7 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import com.google.common.base.Preconditions; import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -52,7 +51,7 @@ public class VhostUserCustomizer extends AbstractInterfaceTypeCustomizer<VhostUs public VhostUserCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext) { super(vppApi); - this.interfaceContext = Preconditions.checkNotNull(interfaceContext, "interfaceContext should not be null"); + this.interfaceContext = interfaceContext; } @Override diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidator.java new file mode 100644 index 000000000..5526bbb22 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VhostUser; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VhostUserValidator implements Validator<VhostUser> { + + public VhostUserValidator(@Nonnull final NamingContext interfaceContext) { + checkNotNull(interfaceContext, "interfaceContext should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + checkNotNull(dataAfter.getSocket(), "Socket cannot be null"); + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, + @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + checkNotNull(dataAfter.getSocket(), "Socket cannot be null"); + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + // there is nothing to validate yet + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizer.java index fba439460..638d7ec62 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizer.java @@ -16,8 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkArgument; - import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer; import io.fd.hc2vpp.common.translate.util.AddressTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -49,8 +47,8 @@ public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> impl private final DisabledInterfacesManager interfaceDisableContext; public VxlanCustomizer(@Nonnull final FutureJVppCore vppApi, - @Nonnull final NamingContext interfaceNamingContext, - @Nonnull final DisabledInterfacesManager interfaceDisableContext) { + @Nonnull final NamingContext interfaceNamingContext, + @Nonnull final DisabledInterfacesManager interfaceDisableContext) { super(vppApi); this.interfaceNamingContext = interfaceNamingContext; this.interfaceDisableContext = interfaceDisableContext; @@ -63,29 +61,27 @@ public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> impl @Override protected final void writeInterface(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter, - @Nonnull final WriteContext writeContext) - throws WriteFailedException { + @Nonnull final WriteContext writeContext) + throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); createVxlanTunnel(id, swIfName, dataAfter, writeContext); } @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, - @Nonnull final WriteContext writeContext) - throws WriteFailedException { + @Nonnull final WriteContext writeContext) + throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteVxlanTunnel(id, swIfName, dataBefore, writeContext); } private void createVxlanTunnel(final InstanceIdentifier<Vxlan> id, final String swIfName, final Vxlan vxlan, - final WriteContext writeContext) - throws WriteFailedException { + final WriteContext writeContext) + throws WriteFailedException { final byte isIpv6 = (byte) (isIpv6(vxlan) - ? 1 - : 0); + ? 1 + : 0); - checkArgument(vxlan.getEncapVrfId() != null && vxlan.getEncapVrfId().getValue() != null, - "encap-vrf-id is mandatory but was not given"); int encapVrfId = vxlan.getEncapVrfId().getValue().intValue(); int vni = vxlan.getVni().getValue().intValue(); @@ -98,8 +94,8 @@ public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> impl LOG.debug("Setting vxlan tunnel for interface: {}. Vxlan: {}", swIfName, vxlan); final CompletionStage<VxlanAddDelTunnelReply> vxlanAddDelTunnelReplyCompletionStage = - getFutureJVpp().vxlanAddDelTunnel(getVxlanTunnelRequest((byte) 1 /* is add */, vxlan.getSrc(), - vxlan.getDst(), encapVrfId, decapNext, vni, isIpv6)); + getFutureJVpp().vxlanAddDelTunnel(getVxlanTunnelRequest((byte) 1 /* is add */, vxlan.getSrc(), + vxlan.getDst(), encapVrfId, decapNext, vni, isIpv6)); final VxlanAddDelTunnelReply reply = getReplyForCreate(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id, vxlan); @@ -131,25 +127,16 @@ public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> impl } private boolean isIpv6(final Vxlan vxlan) { - if (vxlan.getSrc().getIpv4AddressNoZone() == null) { - checkArgument(vxlan.getDst().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", vxlan.getSrc(), - vxlan.getDst()); - return true; - } else { - checkArgument(vxlan.getDst().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", vxlan.getSrc(), - vxlan.getDst()); - return false; - } + return vxlan.getSrc().getIpv4AddressNoZone() == null; + } private void deleteVxlanTunnel(final InstanceIdentifier<Vxlan> id, final String swIfName, final Vxlan vxlan, - final WriteContext writeContext) throws WriteFailedException { + final WriteContext writeContext) throws WriteFailedException { final byte isIpv6 = (byte) (isIpv6(vxlan) - ? 1 - : 0); + ? 1 + : 0); - checkArgument(vxlan.getEncapVrfId() != null && vxlan.getEncapVrfId().getValue() != null, - "encap-vrf-id is mandatory but was not given"); int encapVrfId = vxlan.getEncapVrfId().getValue().intValue(); int vni = vxlan.getVni().getValue().intValue(); @@ -162,8 +149,8 @@ public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> impl LOG.debug("Deleting vxlan tunnel for interface: {}. Vxlan: {}", swIfName, vxlan); final CompletionStage<VxlanAddDelTunnelReply> vxlanAddDelTunnelReplyCompletionStage = - getFutureJVpp().vxlanAddDelTunnel(getVxlanTunnelRequest((byte) 0 /* is add */, vxlan.getSrc(), - vxlan.getDst(), encapVrfId, decapNext, vni, isIpv6)); + getFutureJVpp().vxlanAddDelTunnel(getVxlanTunnelRequest((byte) 0 /* is add */, vxlan.getSrc(), + vxlan.getDst(), encapVrfId, decapNext, vni, isIpv6)); getReplyForDelete(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id); LOG.debug("Vxlan tunnel deleted successfully for: {}, vxlan: {}", swIfName, vxlan); diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizer.java index d61f50b09..b3629415b 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizer.java @@ -16,8 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces; -import static com.google.common.base.Preconditions.checkArgument; - import io.fd.hc2vpp.common.translate.util.AbstractInterfaceTypeCustomizer; import io.fd.hc2vpp.common.translate.util.AddressTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -90,8 +88,9 @@ public class VxlanGpeCustomizer extends AbstractInterfaceTypeCustomizer<VxlanGpe LOG.debug("Setting VxlanGpe tunnel for interface: {}. VxlanGpe: {}", swIfName, vxlanGpe); final CompletionStage<VxlanGpeAddDelTunnelReply> VxlanGpeAddDelTunnelReplyCompletionStage = - getFutureJVpp().vxlanGpeAddDelTunnel(getVxlanGpeTunnelRequest((byte) 1 /* is add */, vxlanGpe.getLocal(), - vxlanGpe.getRemote(), vni, protocol, encapVrfId, decapVrfId, isIpv6)); + getFutureJVpp() + .vxlanGpeAddDelTunnel(getVxlanGpeTunnelRequest((byte) 1 /* is add */, vxlanGpe.getLocal(), + vxlanGpe.getRemote(), vni, protocol, encapVrfId, decapVrfId, isIpv6)); final VxlanGpeAddDelTunnelReply reply = getReplyForCreate(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture(), id, vxlanGpe); @@ -115,17 +114,8 @@ public class VxlanGpeCustomizer extends AbstractInterfaceTypeCustomizer<VxlanGpe } private boolean isIpv6(final VxlanGpe vxlanGpe) { - if (vxlanGpe.getLocal().getIpv4AddressNoZone() == null) { - checkArgument(vxlanGpe.getRemote().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", - vxlanGpe.getLocal(), - vxlanGpe.getRemote()); - return true; - } else { - checkArgument(vxlanGpe.getRemote().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", - vxlanGpe.getLocal(), - vxlanGpe.getRemote()); - return false; - } + return vxlanGpe.getLocal().getIpv4AddressNoZone() == null; + } private void deleteVxlanGpeTunnel(final InstanceIdentifier<VxlanGpe> id, final String swIfName, @@ -143,8 +133,8 @@ public class VxlanGpeCustomizer extends AbstractInterfaceTypeCustomizer<VxlanGpe LOG.debug("Deleting VxlanGpe tunnel for interface: {}. VxlanGpe: {}", swIfName, vxlanGpe); final CompletionStage<VxlanGpeAddDelTunnelReply> VxlanGpeAddDelTunnelReplyCompletionStage = getFutureJVpp() - .vxlanGpeAddDelTunnel(getVxlanGpeTunnelRequest((byte) 0 /* is delete */, vxlanGpe.getLocal(), - vxlanGpe.getRemote(), vni, protocol, encapVrfId, decapVrfId, isIpv6)); + .vxlanGpeAddDelTunnel(getVxlanGpeTunnelRequest((byte) 0 /* is delete */, vxlanGpe.getLocal(), + vxlanGpe.getRemote(), vni, protocol, encapVrfId, decapVrfId, isIpv6)); getReplyForDelete(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture(), id); final int index = interfaceNamingContext.getIndex(swIfName, writeContext.getMappingContext()); // Mark this interface as disabled to not include it in operational reads diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidator.java new file mode 100644 index 000000000..22b5365f5 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidator.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.NamingContext; +import io.fd.hc2vpp.v3po.DisabledInterfacesManager; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VxlanGpe; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VxlanGpeValidator implements Validator<VxlanGpe> { + + public VxlanGpeValidator(@Nonnull final NamingContext interfaceNamingContext, + @Nonnull final DisabledInterfacesManager interfaceDisableContext) { + checkNotNull(interfaceNamingContext, "interfaceContext should not be null"); + checkNotNull(interfaceDisableContext, "DisabledInterfacesManager should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + try { + validateVxlanGpe(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + try { + validateVxlanGpe(dataBefore); + } catch (Exception e) { + throw new DataValidationFailedException.DeleteValidationFailedException(id, e); + } + } + + private void validateVxlanGpe(final VxlanGpe data) { + checkNotNull(data.getLocal(), "Local address cannot be null"); + checkNotNull(data.getRemote(), "Remote address cannot be null"); + if (data.getLocal().getIpv4AddressNoZone() == null) { + checkArgument(data.getRemote().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getLocal(), + data.getRemote()); + } else { + checkArgument(data.getRemote().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getLocal(), + data.getRemote()); + } + checkNotNull(data.getEncapVrfId(), "encap-vrf-id is mandatory but was not given"); + checkNotNull(data.getDecapVrfId(), "decap-vrf-id is mandatory but was not given"); + checkNotNull(data.getVni(), "VNI cannot be null"); + checkNotNull(data.getNextProtocol(), "Next protocol cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidator.java new file mode 100644 index 000000000..1496a884a --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidator.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.NamingContext; +import io.fd.hc2vpp.v3po.DisabledInterfacesManager; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Vxlan; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VxlanValidator implements Validator<Vxlan> { + + public VxlanValidator(@Nonnull final NamingContext interfaceNamingContext, + @Nonnull final DisabledInterfacesManager disabledInterfacesManager) { + checkNotNull(interfaceNamingContext, "interfaceContext should not be null"); + checkNotNull(disabledInterfacesManager, "disabledInterfacesManager should not be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter, + @Nonnull final WriteContext writeContext) + throws CreateValidationFailedException { + try { + validateVxlan(dataAfter); + } catch (Exception e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, + @Nonnull final WriteContext writeContext) + throws DeleteValidationFailedException { + try { + validateVxlan(dataBefore); + } catch (Exception e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private void validateVxlan(final Vxlan data) { + + checkNotNull(data.getSrc(), "Source cannot be null"); + checkNotNull(data.getDst(), "Destination cannot be null"); + if (data.getSrc().getIpv4AddressNoZone() == null) { + checkArgument(data.getDst().getIpv4AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getSrc(), + data.getDst()); + } else { + checkArgument(data.getDst().getIpv6AddressNoZone() == null, "Inconsistent ip addresses: %s, %s", + data.getSrc(), + data.getDst()); + } + checkArgument(data.getEncapVrfId() != null && data.getEncapVrfId().getValue() != null, + "encap-vrf-id is mandatory but was not given"); + checkNotNull(data.getVni(), "VNI cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizer.java index 13fccf7dd..86622663d 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizer.java @@ -16,8 +16,6 @@ package io.fd.hc2vpp.v3po.interfaces.pbb; -import static com.google.common.base.Preconditions.checkNotNull; - import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; import io.fd.hc2vpp.common.translate.util.MacTranslator; @@ -44,7 +42,7 @@ public class PbbRewriteCustomizer extends FutureJVppCustomizer public PbbRewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceNamingContext) { super(futureJVppCore); - this.interfaceNamingContext = checkNotNull(interfaceNamingContext, "Interface naming context cannot be null"); + this.interfaceNamingContext = interfaceNamingContext; } @Override @@ -84,16 +82,16 @@ public class PbbRewriteCustomizer extends FutureJVppCustomizer private void setPbbRewrite(final InstanceIdentifier<PbbRewrite> id, final PbbRewrite data, final WriteContext writeContext, final boolean disable) throws TimeoutException, VppBaseCallException { - final String interfaceName = checkNotNull(id.firstKeyOf(Interface.class), "Interface key not found").getName(); + final String interfaceName = id.firstKeyOf(Interface.class).getName(); final L2InterfacePbbTagRewrite request = new L2InterfacePbbTagRewrite(); //checking all attributes in preconditions(pbb-rewrite is subcontainer, so there can't be mandatory statements) request.swIfIndex = interfaceNamingContext.getIndex(interfaceName, writeContext.getMappingContext()); - request.bDmac = parseMac(verifiedDestinationAddress(data)); - request.bSmac = parseMac(verifiedSourceAddress(data)); - request.bVlanid = verifiedBVlanId(data); - request.iSid = verifiedISid(data); + request.bDmac = parseMac(data.getDestinationAddress().getValue()); + request.bSmac = parseMac(data.getSourceAddress().getValue()); + request.bVlanid = data.getBVlanTagVlanId().shortValue(); + request.iSid = data.getITagIsid().intValue(); request.vtrOp = verifiedOperation(data, disable); //not sure whats gonna happen to this attribute, so its left optional for now @@ -104,27 +102,10 @@ public class PbbRewriteCustomizer extends FutureJVppCustomizer getReply(getFutureJVpp().l2InterfacePbbTagRewrite(request).toCompletableFuture()); } - private String verifiedDestinationAddress(final PbbRewrite data) { - return checkNotNull(data.getDestinationAddress(), "Destination address cannot be null").getValue(); - } - - private String verifiedSourceAddress(final PbbRewrite data) { - return checkNotNull(data.getSourceAddress(), "Destination address cannot be null").getValue(); - } - - private short verifiedBVlanId(final PbbRewrite data) { - return checkNotNull(data.getBVlanTagVlanId(), "BVlan id cannot be null").shortValue(); - } - - private int verifiedISid(final PbbRewrite data) { - return checkNotNull(data.getITagIsid(), "ISid cannot be null").intValue(); - } - // if disabled ,then uses non-public allowed value 0, which is equal to operation disable private int verifiedOperation(final PbbRewrite data, final boolean disable) { - return disable ? OPERATION_DISABLE - : checkNotNull(data.getInterfaceOperation(), "Operation cannot be null").getIntValue(); + : data.getInterfaceOperation().getIntValue(); } } diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidator.java new file mode 100644 index 000000000..e5ec7fc69 --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidator.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.pbb; + +import static com.google.common.base.Preconditions.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewrite; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PbbRewriteValidator implements Validator<PbbRewrite> { + + + public PbbRewriteValidator(@Nonnull final NamingContext interfaceNamingContext) { + checkNotNull(interfaceNamingContext, "Interface naming context cannot be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + try { + validatePbbRewrite(id, dataAfter, false); + } catch(Exception e) { + throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, + @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + + try { + validatePbbRewrite(id, dataAfter, false); + } catch(Exception e) { + throw new DataValidationFailedException.UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + try { + validatePbbRewrite(id, dataBefore, true); + } catch(Exception e) { + throw new DataValidationFailedException.DeleteValidationFailedException(id, e); + } + } + + private void validatePbbRewrite(final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite data, + final boolean disable) { + checkNotNull(id.firstKeyOf(Interface.class), "Interface key not found"); + checkNotNull(data.getDestinationAddress(), "Destination address cannot be null"); + checkNotNull(data.getSourceAddress(), "Source address cannot be null"); + checkNotNull(data.getBVlanTagVlanId(), "BVlan id cannot be null"); + checkNotNull(data.getITagIsid(), "ISid cannot be null"); + if (disable) { + checkNotNull(data.getInterfaceOperation(), "Operation cannot be null"); + } + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceValidator.java b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceValidator.java new file mode 100644 index 000000000..f51ad6f0c --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfaceValidator.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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 com.google.common.base.Preconditions.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.function.Function; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MirroredInterfaceValidator implements Validator<MirroredInterface> { + + public MirroredInterfaceValidator(@Nonnull final NamingContext ifcContext, + @Nonnull final Function<InstanceIdentifier<MirroredInterfaces>, String> destinationInterfaceNameExtractor) { + checkNotNull(ifcContext, "Interface naming context cannot be null"); + checkNotNull(destinationInterfaceNameExtractor, "Destination Interface Name extractor cannot be null"); + } + + @Override + public void validateWrite(@Nonnull final InstanceIdentifier<MirroredInterface> id, + @Nonnull final MirroredInterface dataAfter, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.CreateValidationFailedException { + try { + checkMirroredInterfaceData(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(@Nonnull final InstanceIdentifier<MirroredInterface> id, + @Nonnull final MirroredInterface dataBefore, + @Nonnull final MirroredInterface dataAfter, @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.UpdateValidationFailedException { + try { + checkMirroredInterfaceData(dataAfter); + } catch (Exception e) { + throw new DataValidationFailedException.UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(@Nonnull final InstanceIdentifier<MirroredInterface> id, + @Nonnull final MirroredInterface dataBefore, + @Nonnull final WriteContext writeContext) + throws DataValidationFailedException.DeleteValidationFailedException { + try { + checkMirroredInterfaceData(dataBefore); + } catch (Exception e) { + throw new DataValidationFailedException.DeleteValidationFailedException(id, e); + } + } + + private void checkMirroredInterfaceData(final MirroredInterface data) { + checkNotNull(data.getIfaceRef(), "IfaceRef cannot be null"); + checkNotNull(data.getState(), "State cannot be null"); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidatorTest.java new file mode 100644 index 000000000..ebdc770fe --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AfPacketValidatorTest.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.AfPacket; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.AfPacketBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AfPacketValidatorTest { + + private AfPacketValidator validator; + + @Mock + private WriteContext writeContext; + + private final String IFACE_NAME = "veth1"; + private final InstanceIdentifier<AfPacket> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(AfPacket.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new AfPacketValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, afPacket(IFACE_NAME), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoHostName() throws CreateValidationFailedException { + validator.validateWrite(ID, afPacket(null), writeContext); + } + + @Test(expected = IllegalArgumentException.class) + public void testWriteFailedLongHostName() throws CreateValidationFailedException { + validator.validateWrite(ID, + afPacket(IntStream.range(1, 64).boxed().map(i -> i.toString()).collect(Collectors.joining(","))), + writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + validator.validateUpdate(ID, afPacket(IFACE_NAME), afPacket(IFACE_NAME), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, afPacket(IFACE_NAME), writeContext); + } + + private AfPacket afPacket(String name) { + return new AfPacketBuilder().setHostInterfaceName(name).build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetCustomizerTest.java index 18ec6614d..f7befc4e9 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetCustomizerTest.java @@ -29,7 +29,6 @@ import io.fd.jvpp.core.dto.HwInterfaceSetMtuReply; import org.junit.Test; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Ethernet; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.EthernetBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev180703.EthernetCsmacd; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; @@ -57,7 +56,7 @@ public class EthernetCustomizerTest extends WriterCustomizerTest { public void testWrite() throws WriteFailedException { when(api.hwInterfaceSetMtu(any())).thenReturn(future(new HwInterfaceSetMtuReply())); final int mtu = 1234; - customizer.writeCurrentAttributes(IF_IID, ethernet(mtu), writeContext); + customizer.writeCurrentAttributes(IF_IID, EthernetValidatorTest.ethernet(mtu), writeContext); verify(api).hwInterfaceSetMtu(mtuSetRequest(mtu)); } @@ -65,7 +64,7 @@ public class EthernetCustomizerTest extends WriterCustomizerTest { public void testUpdate() throws WriteFailedException { when(api.hwInterfaceSetMtu(any())).thenReturn(future(new HwInterfaceSetMtuReply())); final int mtu = 5678; - customizer.updateCurrentAttributes(IF_IID, mock(Ethernet.class), ethernet(mtu), writeContext); + customizer.updateCurrentAttributes(IF_IID, mock(Ethernet.class), EthernetValidatorTest.ethernet(mtu), writeContext); verify(api).hwInterfaceSetMtu(mtuSetRequest(mtu)); } @@ -80,11 +79,4 @@ public class EthernetCustomizerTest extends WriterCustomizerTest { public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IF_IID, mock(Ethernet.class), writeContext); } - - private static Ethernet ethernet(final int mtu) { - final EthernetBuilder ethernet = new EthernetBuilder(); - ethernet.setMtu(mtu); - return ethernet.build(); - } - } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidatorTest.java new file mode 100644 index 000000000..ce639d22f --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/EthernetValidatorTest.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Ethernet; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.EthernetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class EthernetValidatorTest { + + private EthernetValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth0"; + private static final int IF_MTU = 1234; + private static final InstanceIdentifier<Ethernet> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation( + VppInterfaceAugmentation.class).child(Ethernet.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new EthernetValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, ethernet(IF_MTU), writeContext); + } + + @Test(expected = NullPointerException.class) + public void testWriteFailedNoMTU() throws CreateValidationFailedException { + validator.validateWrite(ID, ethernet(null), writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + validator.validateUpdate(ID, ethernet(IF_MTU), ethernet(IF_MTU + 1), writeContext); + } + + static Ethernet ethernet(final Integer mtu) { + final EthernetBuilder ethernet = new EthernetBuilder(); + ethernet.setMtu(mtu); + return ethernet.build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreValidatorTest.java new file mode 100644 index 000000000..e7f786bde --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreValidatorTest.java @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Gre; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.GreBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GreValidatorTest { + + private GreValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IPV6 = "a::100"; + private static final String IPV4_1 = "192.168.20.10"; + private static final String IPV4_2 = "192.168.20.11"; + private static final Long OUT_FIB_ID = Long.valueOf(123); + private static final String IFACE_NAME = "eth0"; + private static final InstanceIdentifier<Gre> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(Gre.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new GreValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, generateCorrectGre(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedMixedIpv4Ipv6() throws CreateValidationFailedException { + validator.validateWrite(ID, generateGre(ip4(IPV4_1), ip6(IPV6), OUT_FIB_ID), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoSrcAddr() throws CreateValidationFailedException { + validator.validateWrite(ID, generateGre(null, ip6(IPV6), OUT_FIB_ID), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoDstAddr() throws CreateValidationFailedException { + validator.validateWrite(ID, generateGre(ip4(IPV4_1), null, OUT_FIB_ID), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoOutFibId() throws CreateValidationFailedException { + validator.validateWrite(ID, generateGre(ip4(IPV4_1), ip4(IPV4_2), null), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, generateCorrectGre(), writeContext); + } + + private Gre generateCorrectGre() { + return generateGre(ip4(IPV4_1), ip4(IPV4_2), OUT_FIB_ID); + } + + private Gre generateGre(final IpAddressNoZone srcAddr, final IpAddressNoZone dstAddr, final Long outerFibId) { + final GreBuilder builder = new GreBuilder(); + builder.setSrc(srcAddr); + builder.setDst(dstAddr); + builder.setOuterFibId(outerFibId); + return builder.build(); + } + + private IpAddressNoZone ip4(String addr) { + return new IpAddressNoZone(new Ipv4AddressNoZone(addr)); + } + + private IpAddressNoZone ip6(String addr) { + return new IpAddressNoZone(new Ipv6AddressNoZone(addr)); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizerTest.java index a3028acf7..533c627f6 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingCustomizerTest.java @@ -20,14 +20,12 @@ import static org.mockito.Matchers.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import java.util.Optional; import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; import io.fd.hc2vpp.common.translate.util.NamingContext; -import io.fd.honeycomb.translate.util.RWUtils; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.jvpp.core.dto.SwInterfaceSetTable; import io.fd.jvpp.core.dto.SwInterfaceSetTableReply; -import java.util.Collections; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Routing; @@ -37,11 +35,6 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces. import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1Builder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4Builder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv6Builder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class InterfaceRoutingCustomizerTest extends WriterCustomizerTest { @@ -76,52 +69,16 @@ public class InterfaceRoutingCustomizerTest extends WriterCustomizerTest { customizer.writeCurrentAttributes(IID, routing(213), writeContext); } - @Test(expected = IllegalStateException.class) - public void testWriteFailedIpv4Present() throws WriteFailedException { - when(writeContext.readBefore(RWUtils.cutId(IID, Interface.class))) - .thenReturn(Optional.of(ifaceWithV4Address())); - customizer.writeCurrentAttributes(IID, routing(213), writeContext); - } - - @Test(expected = IllegalStateException.class) - public void testWriteFailedIpv6Present() throws WriteFailedException { - when(writeContext.readBefore(RWUtils.cutId(IID, Interface.class))) - .thenReturn(Optional.of(ifaceWithV6Address())); - customizer.writeCurrentAttributes(IID, routing(213), writeContext); - } - @Test public void testWriteEmptyIfaceData() throws WriteFailedException { - when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(new InterfaceBuilder().build())); + when(writeContext.readBefore(any(InstanceIdentifier.class))) + .thenReturn(Optional.of(new InterfaceBuilder().build())); final int vrfId = 123; when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply())); customizer.writeCurrentAttributes(IID, routing(vrfId), writeContext); verify(api).swInterfaceSetTable(expectedRequest(vrfId)); } - private static Interface ifaceWithV4Address() { - return new InterfaceBuilder() - .addAugmentation(Interface1.class, new Interface1Builder() - .setIpv4(new Ipv4Builder() - .setAddress(Collections.singletonList(new AddressBuilder().build())) - .build()) - .build()) - .build(); - } - - - private static Interface ifaceWithV6Address() { - return new InterfaceBuilder() - .addAugmentation(Interface1.class, new Interface1Builder() - .setIpv6(new Ipv6Builder() - .setAddress(Collections.singletonList( - new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv6.AddressBuilder() - .build())) - .build()) - .build()) - .build(); - } - @Test(expected = WriteFailedException.class) public void testUpdateFailed() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidatorTest.java new file mode 100644 index 000000000..e10aba4a2 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceRoutingValidatorTest.java @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.util.RWUtils; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.Collections; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Routing; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.RoutingBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.VniReference; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv6Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceRoutingValidatorTest { + + private InterfaceRoutingValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth1"; + private static final Long VRF_ID = Long.valueOf(123); + + private static final InstanceIdentifier<Routing> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(Routing.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new InterfaceRoutingValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateWrite(ID, routing(VRF_ID, true, false), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoFrfIds() throws CreateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateWrite(ID, routing(null, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedWithV4Address() throws CreateValidationFailedException { + when(writeContext.readBefore(RWUtils.cutId(ID, Interface.class))) + .thenReturn(Optional.of(ifaceWithV4Address())); + validator.validateWrite(ID, routing(VRF_ID, true, false), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedWithV6Address() throws CreateValidationFailedException { + when(writeContext.readBefore(RWUtils.cutId(ID, Interface.class))) + .thenReturn(Optional.of(ifaceWithV6Address())); + validator.validateWrite(ID, routing(VRF_ID, true, false), writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateUpdate(ID, routing(VRF_ID, true, false), + routing(VRF_ID, true, true), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateDelete(ID, routing(VRF_ID, true, false), writeContext); + } + + private Routing routing(final Long vrfId, final boolean hasIpv4, final boolean hasIpv6) { + VniReference vni = null; + if (vrfId != null) { + vni = new VniReference(vrfId); + } + + RoutingBuilder builder = new RoutingBuilder(); + if (hasIpv4) { + builder.setIpv4VrfId(vni); + } + if (hasIpv6) { + builder.setIpv6VrfId(vni); + } + return builder.build(); + } + + private Interface ifaceWithV4Address() { + return new InterfaceBuilder() + .addAugmentation(Interface1.class, new Interface1Builder() + .setIpv4(new Ipv4Builder() + .setAddress(Collections.singletonList(new AddressBuilder().build())) + .build()) + .build()) + .build(); + } + + private Interface ifaceWithV6Address() { + return new InterfaceBuilder() + .addAugmentation(Interface1.class, new Interface1Builder() + .setIpv6(new Ipv6Builder() + .setAddress(Collections.singletonList( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv6.AddressBuilder() + .build())) + .build()) + .build()) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidatorTest.java new file mode 100644 index 000000000..79b3f9185 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceUnnumberedValidatorTest.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.InterfaceUnnumberedAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.Unnumbered; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.UnnumberedBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceUnnumberedValidatorTest { + + private InterfaceUnnumberedValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth2"; + private static final String TARGET_IFC0_NAME = "eth0"; + private static final InstanceIdentifier<Unnumbered> ID = InstanceIdentifier.create(Interfaces.class) + .child(Interface.class, new InterfaceKey(IF_NAME)) + .augmentation(InterfaceUnnumberedAugmentation.class) + .child(Unnumbered.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new InterfaceUnnumberedValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); + } + + @Test(expected = NullPointerException.class) + public void testWriteFailedNoUse() throws CreateValidationFailedException { + validator.validateWrite(ID, getUnnumberedIfc(null), writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + validator.validateUpdate(ID, getUnnumberedIfc(TARGET_IFC0_NAME), getUnnumberedIfc(TARGET_IFC0_NAME), + writeContext); + } + + @Test + public void testDeleteeSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); + } + + private Unnumbered getUnnumberedIfc(String use) { + return new UnnumberedBuilder().setUse(use).build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidatorTest.java new file mode 100644 index 000000000..21de26fed --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceValidatorTest.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceValidatorTest { + + private InterfaceValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth0"; + private static final InstanceIdentifier<Interface> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new InterfaceValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, getInterface(true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoName() throws CreateValidationFailedException { + validator.validateWrite(ID, getInterface(null, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoEnableFlag() throws CreateValidationFailedException { + validator.validateWrite(ID, getInterface(null), writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + validator.validateUpdate(ID, getInterface(true), getInterface(true), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, getInterface(true), writeContext); + } + + private Interface getInterface(final String name, final Boolean enabled) { + return new InterfaceBuilder().setName(name).setEnabled(enabled).build(); + } + + private Interface getInterface(final Boolean enabled) { + return new InterfaceBuilder().setName(IF_NAME).setEnabled(enabled).build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java index 6c6a2be09..37a185d6a 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java @@ -95,13 +95,13 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { return tag.build(); } - private static Match generateMatch() { + static Match generateMatch() { final MatchBuilder match = new MatchBuilder(); final VlanTaggedBuilder tagged = new VlanTaggedBuilder(); tagged.setMatchExactTags(true); match.setMatchType( - new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.match.attributes.match.type.VlanTaggedBuilder() - .setVlanTagged(tagged.build()).build()); + new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.match.attributes.match.type.VlanTaggedBuilder() + .setVlanTagged(tagged.build()).build()); return match.build(); } @@ -136,8 +136,8 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { request.twoTags = 1; request.innerVlanId = innerVlanId; request.innerVlanIdAny = (byte) (isInnerAny - ? 1 - : 0); + ? 1 + : 0); request.dot1Ad = 1; request.outerVlanId = STAG_ID; request.exactMatch = 1; @@ -153,8 +153,8 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { private InstanceIdentifier<SubInterface> getSubInterfaceId(final String name, final long index) { return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation( - SubinterfaceAugmentation.class).child(SubInterfaces.class) - .child(SubInterface.class, new SubInterfaceKey(index)); + SubinterfaceAugmentation.class).child(SubInterfaces.class) + .child(SubInterface.class, new SubInterfaceKey(index)); } private void whenCreateSubifThenSuccess() { @@ -173,7 +173,7 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { } private SwInterfaceSetFlags verifySwInterfaceSetFlagsWasInvoked(final SwInterfaceSetFlags expected) - throws VppBaseCallException { + throws VppBaseCallException { ArgumentCaptor<SwInterfaceSetFlags> argumentCaptor = ArgumentCaptor.forClass(SwInterfaceSetFlags.class); verify(api).swInterfaceSetFlags(argumentCaptor.capture()); final SwInterfaceSetFlags actual = argumentCaptor.getValue(); @@ -195,8 +195,8 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false)); verify(mappingContext) - .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq( - mapping(SUB_IFACE_NAME, 0).get())); + .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq( + mapping(SUB_IFACE_NAME, 0).get())); } @Test @@ -211,8 +211,8 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ANY_ID, true)); verify(mappingContext) - .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq( - mapping(SUB_IFACE_NAME, 0).get())); + .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq( + mapping(SUB_IFACE_NAME, 0).get())); } @Test @@ -228,8 +228,8 @@ public class SubInterfaceCustomizerTest extends WriterCustomizerTest { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false)); verify(mappingContext, times(0)).put( - eq(mappingIid(SUPER_IF_NAME, IFC_TEST_INSTANCE)), - eq(mapping(SUPER_IF_NAME, 0).get())); + eq(mappingIid(SUPER_IF_NAME, IFC_TEST_INSTANCE)), + eq(mapping(SUPER_IF_NAME, 0).get())); return; } fail("WriteFailedException.CreateFailedException was expected"); diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizerTest.java index 5732d587b..90c9d66c8 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingCustomizerTest.java @@ -21,7 +21,6 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import java.util.Optional; import com.google.common.collect.ImmutableSet; import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; @@ -30,6 +29,7 @@ import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.jvpp.core.dto.SwInterfaceSetTable; import io.fd.jvpp.core.dto.SwInterfaceSetTableReply; import java.util.Collections; +import java.util.Optional; import java.util.Set; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -38,11 +38,7 @@ import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.managem import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.SubinterfaceAugmentation; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.SubInterfaces; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceBuilder; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceKey; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.Ipv4Builder; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.ipv4.AddressBuilder; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.Ipv6Builder; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.Routing; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.RoutingBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; @@ -80,20 +76,6 @@ public class SubInterfaceRoutingCustomizerTest extends WriterCustomizerTest impl when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply())); } - @Test(expected = IllegalStateException.class) - public void testWriteFailedV4AddressPresent() throws WriteFailedException { - when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v4AddressPresent())); - final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build(); - customizer.writeCurrentAttributes(VALID_ID, v4Routing, writeContext); - } - - @Test(expected = IllegalStateException.class) - public void testWriteFailedV6AddressPresent() throws WriteFailedException { - when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v6AddressPresent())); - final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build(); - customizer.writeCurrentAttributes(VALID_ID, v4Routing, writeContext); - } - @Test public void testWriteIpv4Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); @@ -102,7 +84,6 @@ public class SubInterfaceRoutingCustomizerTest extends WriterCustomizerTest impl verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, 4))); } - @Test public void testWriteIpv6Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); @@ -115,9 +96,9 @@ public class SubInterfaceRoutingCustomizerTest extends WriterCustomizerTest impl public void testUpdateIpv4Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing routingBefore = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)) - .setIpv4VrfId(new VniReference(4L)).build(); + .setIpv4VrfId(new VniReference(4L)).build(); final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)) - .setIpv4VrfId(new VniReference(5L)).build(); + .setIpv4VrfId(new VniReference(5L)).build(); customizer.updateCurrentAttributes(VALID_ID, routingBefore, routingAfter, writeContext); verifySetTableRequest(2, ImmutableSet.of(request(false, SUBIF_INDEX, 5), request(true, SUBIF_INDEX, 3))); @@ -127,9 +108,9 @@ public class SubInterfaceRoutingCustomizerTest extends WriterCustomizerTest impl public void testUpdateIpv6Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing routingBefore = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)) - .setIpv4VrfId(new VniReference(4L)).build(); + .setIpv4VrfId(new VniReference(4L)).build(); final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(8L)) - .setIpv4VrfId(new VniReference(4L)).build(); + .setIpv4VrfId(new VniReference(4L)).build(); customizer.updateCurrentAttributes(VALID_ID, routingBefore, routingAfter, writeContext); verifySetTableRequest(2, ImmutableSet.of(request(false, SUBIF_INDEX, 4), request(true, SUBIF_INDEX, 8))); @@ -164,20 +145,4 @@ public class SubInterfaceRoutingCustomizerTest extends WriterCustomizerTest impl verify(api, times(times)).swInterfaceSetTable(requestCaptor.capture()); requestCaptor.getAllValues().containsAll(requests); } - - private static SubInterface v4AddressPresent() { - return new SubInterfaceBuilder() - .setIpv4(new Ipv4Builder() - .setAddress(Collections.singletonList(new AddressBuilder().build())) - .build()) - .build(); - } - - private static SubInterface v6AddressPresent(){ - return new SubInterfaceBuilder() - .setIpv6(new Ipv6Builder() - .setAddress(Collections.singletonList(new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.ipv6.AddressBuilder().build())) - .build()) - .build(); - } } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidatorTest.java new file mode 100644 index 000000000..510887e70 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceRoutingValidatorTest.java @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.Collections; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.VniReference; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.SubinterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.SubInterfaces; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceKey; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.Ipv4Builder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip4.attributes.ipv4.AddressBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.Ipv6Builder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.Routing; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.routing.attributes.RoutingBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceRoutingValidatorTest { + + private SubInterfaceRoutingValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth1"; + private static final int SUBIF_INDEX = 0; + private static final InstanceIdentifier<Routing> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)) + .augmentation(SubinterfaceAugmentation.class) + .child(SubInterfaces.class) + .child(SubInterface.class, new SubInterfaceKey((long) SUBIF_INDEX)) + .child(Routing.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new SubInterfaceRoutingValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateWrite(ID, getRouting(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedV4AddressPresent() throws CreateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v4AddressPresent())); + validator.validateWrite(ID, getRouting(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedV6AddressPresent() throws CreateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v6AddressPresent())); + validator.validateWrite(ID, getRouting(), writeContext); + } + + @Test + public void testUpdateSuccessful() throws UpdateValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateUpdate(ID, getRouting(), getRouting(), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); + validator.validateDelete(ID, getRouting(), writeContext); + } + + private Routing getRouting() { + return new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build(); + } + + private SubInterface v4AddressPresent() { + return new SubInterfaceBuilder() + .setIpv4(new Ipv4Builder() + .setAddress(Collections.singletonList(new AddressBuilder().build())) + .build()) + .build(); + } + + private SubInterface v6AddressPresent() { + return new SubInterfaceBuilder() + .setIpv6(new Ipv6Builder() + .setAddress(Collections.singletonList( + new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.ip6.attributes.ipv6.AddressBuilder() + .build())) + .build()) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedCustomizerTest.java index 5c640d204..fdaf6f925 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedCustomizerTest.java @@ -34,10 +34,10 @@ public class SubInterfaceUnnumberedCustomizerTest extends AbstractUnnumberedCust private static final int UNNUMBERED_IFC_ID = 2; private static final long UNNUMBERED_IFC_NUMBER = 123; private static final InstanceIdentifier<Unnumbered> UNNUMBERED_IFC_IID = InstanceIdentifier.create(Interfaces.class) - .child(Interface.class, new InterfaceKey(PARENT_IFC_NAME)) - .augmentation(SubinterfaceAugmentation.class).child(SubInterfaces.class) - .child(SubInterface.class, new SubInterfaceKey(UNNUMBERED_IFC_NUMBER)).augmentation( - SubinterfaceUnnumberedAugmentation.class).child(Unnumbered.class); + .child(Interface.class, new InterfaceKey(PARENT_IFC_NAME)) + .augmentation(SubinterfaceAugmentation.class).child(SubInterfaces.class) + .child(SubInterface.class, new SubInterfaceKey(UNNUMBERED_IFC_NUMBER)) + .augmentation(SubinterfaceUnnumberedAugmentation.class).child(Unnumbered.class); @Override protected int getUnnumberedIfcId() { @@ -58,5 +58,4 @@ public class SubInterfaceUnnumberedCustomizerTest extends AbstractUnnumberedCust protected AbstractUnnumberedCustomizer getCustomizer() { return new SubInterfaceUnnumberedCustomizer(api, new NamingContext("ifc-prefix", IFC_CTX_NAME)); } - } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidatorTest.java new file mode 100644 index 000000000..73043be8b --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceUnnumberedValidatorTest.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.InterfaceUnnumberedAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.Unnumbered; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.unnumbered.interfaces.rev180103.unnumbered.config.attributes.UnnumberedBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceUnnumberedValidatorTest { + + private SubInterfaceUnnumberedValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String IF_NAME = "eth2"; + private static final String TARGET_IFC0_NAME = "eth0"; + private static final InstanceIdentifier<Unnumbered> ID = InstanceIdentifier.create(Interfaces.class) + .child(Interface.class, new InterfaceKey(IF_NAME)) + .augmentation(InterfaceUnnumberedAugmentation.class) + .child(Unnumbered.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new SubInterfaceUnnumberedValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws DataValidationFailedException.CreateValidationFailedException { + validator.validateWrite(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); + } + + @Test(expected = NullPointerException.class) + public void testWriteFailedNoUse() throws DataValidationFailedException.CreateValidationFailedException { + validator.validateWrite(ID, getUnnumberedIfc(null), writeContext); + } + + @Test + public void testUpdateSuccessful() throws DataValidationFailedException.UpdateValidationFailedException { + validator.validateUpdate(ID, getUnnumberedIfc(TARGET_IFC0_NAME), getUnnumberedIfc(TARGET_IFC0_NAME), + writeContext); + } + + @Test + public void testDeleteeSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { + validator.validateDelete(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); + } + + private Unnumbered getUnnumberedIfc(String use) { + return new UnnumberedBuilder().setUse(use).build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidatorTest.java new file mode 100644 index 000000000..e7b9e668b --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceValidatorTest.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.SubinterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.SubInterfaces; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterface; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.interfaces._interface.sub.interfaces.SubInterfaceKey; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.vlan.rev180319.sub._interface.base.attributes.Match; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class SubInterfaceValidatorTest { + + private SubInterfaceValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String SUPER_IF_NAME = "local0"; + private static final String SUB_IFACE_NAME = "local0.11"; + private static final long SUBIF_INDEX = 11; + private static final InstanceIdentifier<SubInterface> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(SUPER_IF_NAME)) + .augmentation( + SubinterfaceAugmentation.class).child(SubInterfaces.class) + .child(SubInterface.class, new SubInterfaceKey(SUBIF_INDEX)); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new SubInterfaceValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator + .validateWrite(ID, generateSubInterface(11L, SubInterfaceCustomizerTest.generateMatch()), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoIdentifier() throws CreateValidationFailedException { + validator.validateWrite(ID, generateSubInterface(null, SubInterfaceCustomizerTest.generateMatch()), + writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoMatch() throws CreateValidationFailedException { + validator.validateWrite(ID, generateSubInterface(11L, null), writeContext); + } + + private SubInterface generateSubInterface(final Long identifier, final Match match) { + return new SubInterfaceBuilder() + .setIdentifier(identifier) + .setMatch(match) + .setEnabled(true) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java index ea3b699a7..db190ee06 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java @@ -61,7 +61,7 @@ public class VhostUserCustomizerTest extends WriterCustomizerTest implements Ipv .augmentation(VppInterfaceAugmentation.class).child(VhostUser.class); private VhostUserCustomizer customizer; - private static VhostUser generateVhostUser(final VhostUserRole role, final String socketName) { + static VhostUser generateVhostUser(final VhostUserRole role, final String socketName) { VhostUserBuilder builder = new VhostUserBuilder(); builder.setRole(role); builder.setSocket(socketName); @@ -121,7 +121,7 @@ public class VhostUserCustomizerTest extends WriterCustomizerTest implements Ipv customizer.writeCurrentAttributes(ID, vhostUser, writeContext); verifyCreateVhostUserIfWasInvoked(vhostUser); verify(mappingContext).put(eq(mappingIid(IFACE_NAME, "test-instance")), eq( - mapping(IFACE_NAME, 0).get())); + mapping(IFACE_NAME, 0).get())); } @Test diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidatorTest.java new file mode 100644 index 000000000..eb8541270 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserValidatorTest.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VhostUserRole; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VhostUser; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VhostUserValidatorTest { + + private VhostUserValidator validator; + + @Mock + private WriteContext writeContext; + + private static final String SOCKET = "testSocket"; + private static final String IFACE_NAME = "eth0"; + private static final InstanceIdentifier<VhostUser> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(VhostUser.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new VhostUserValidator(ifcContext); + } + + @Test + public void testWriteSuccessful() throws DataValidationFailedException.CreateValidationFailedException { + validator.validateWrite(ID, getVhostUser(SOCKET), writeContext); + } + + @Test(expected = NullPointerException.class) + public void testWriteFailedNoSocket() throws DataValidationFailedException.CreateValidationFailedException { + validator.validateWrite(ID, getVhostUser(null), writeContext); + } + + @Test + public void testUpdateSuccessful() throws DataValidationFailedException.UpdateValidationFailedException { + validator.validateUpdate(ID, getVhostUser(SOCKET), + getVhostUser(SOCKET), writeContext); + } + + @Test + public void testDeleteeSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { + validator.validateDelete(ID, getVhostUser(SOCKET), writeContext); + } + + private VhostUser getVhostUser(final String socketName) { + return VhostUserCustomizerTest.generateVhostUser(VhostUserRole.Client, socketName); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidatorTest.java new file mode 100644 index 000000000..c4955d881 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeValidatorTest.java @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.v3po.DisabledInterfacesManager; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VxlanGpeNextProtocol; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VxlanGpeVni; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VxlanGpe; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VxlanGpeBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VxlanGpeValidatorTest { + + private VxlanGpeValidator validator; + + @Mock + private WriteContext writeContext; + @Mock + private DisabledInterfacesManager interfaceDisableContext; + + private static final String IPV6 = "a::100"; + private static final String IPV4_1 = "192.168.20.10"; + private static final String IPV4_2 = "192.168.20.11"; + private static final Long VNI = Long.valueOf(11); + private static final Long ENCAP = Long.valueOf(123); + private static final Long DECAP = Long.valueOf(321); + private static final String IFACE_NAME = "eth0"; + private static final InstanceIdentifier<VxlanGpe> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(VxlanGpe.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new VxlanGpeValidator(ifcContext, interfaceDisableContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanCorrect(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedMixedIpFamilies() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanMixedIpFamilies(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoLocal() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(false, true, true, true, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoRemote() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, false, true, true, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoEncapVrfId() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, false, true, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoDecapVrfId() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, true, false, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoVNI() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, true, true, false, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoNextProtocol() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, true, true, true, false), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, generateVxlanCorrect(), writeContext); + } + + private VxlanGpe generateVxlanSetFields(final boolean src, final boolean dst, final boolean encapVrfId, + final boolean decapVrfId, final boolean vni, final boolean protocol) { + final VxlanGpeBuilder builder = new VxlanGpeBuilder(); + builder.setLocal(src + ? new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_1)) + : null); + builder.setRemote(dst + ? new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_2)) + : null); + builder.setEncapVrfId(encapVrfId + ? ENCAP + : null); + builder.setDecapVrfId(decapVrfId + ? DECAP + : null); + builder.setVni(vni + ? new VxlanGpeVni(VNI) + : null); + builder.setNextProtocol(protocol + ? VxlanGpeNextProtocol.forValue(1) + : null); + return builder.build(); + } + + private VxlanGpe generateVxlanCorrect() { + return generateVxlanSetFields(true, true, true, true, true, true); + } + + private VxlanGpe generateVxlanMixedIpFamilies() { + return new VxlanGpeBuilder() + .setLocal(new IpAddressNoZone(new Ipv6AddressNoZone(IPV6))) + .setRemote(new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_1))) + .setEncapVrfId(ENCAP).setDecapVrfId(DECAP) + .setVni(new VxlanGpeVni(VNI)) + .setNextProtocol(VxlanGpeNextProtocol.forValue(1)) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidatorTest.java new file mode 100644 index 000000000..587b9f313 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanValidatorTest.java @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.v3po.DisabledInterfacesManager; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.L2Input; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VxlanVni; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Vxlan; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.VxlanBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.VniReference; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VxlanValidatorTest { + + private VxlanValidator validator; + + @Mock + private WriteContext writeContext; + @Mock + private DisabledInterfacesManager interfaceDisableContext; + + private static final String IPV6 = "a::100"; + private static final String IPV4_1 = "192.168.20.10"; + private static final String IPV4_2 = "192.168.20.11"; + private static final Long VNI = Long.valueOf(11); + private static final Long ENCAP = Long.valueOf(123); + private static final String IFACE_NAME = "eth0"; + private static final InstanceIdentifier<Vxlan> ID = + InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(Vxlan.class); + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new VxlanValidator(ifcContext, interfaceDisableContext); + } + + @Test + public void testWriteSuccessful() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanCorrect(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedMixedIpFamilies() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanMixedIpFamilies(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoSrc() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(false, true, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoDst() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, false, true, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoEncap() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, false, true), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedNoVNI() throws CreateValidationFailedException { + validator.validateWrite(ID, generateVxlanSetFields(true, true, true, false), writeContext); + } + + @Test + public void testDeleteSuccessful() throws DeleteValidationFailedException { + validator.validateDelete(ID, generateVxlanCorrect(), writeContext); + } + + private Vxlan generateVxlan(final IpAddressNoZone src, final IpAddressNoZone dst, final VniReference encapVrfId, + final long vni) { + final VxlanBuilder builder = new VxlanBuilder(); + builder.setSrc(src); + builder.setDst(dst); + builder.setEncapVrfId(encapVrfId); + builder.setVni(new VxlanVni(vni)); + builder.setDecapNext(L2Input.class); + return builder.build(); + } + + private Vxlan generateVxlanSetFields(final boolean src, final boolean dst, final boolean encapVrfId, + final boolean vni) { + final VxlanBuilder builder = new VxlanBuilder(); + builder.setSrc(src + ? new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_1)) + : null); + builder.setDst(dst + ? new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_2)) + : null); + builder.setEncapVrfId(encapVrfId + ? new VniReference(ENCAP) + : null); + builder.setVni(vni + ? new VxlanVni(VNI) + : null); + builder.setDecapNext(L2Input.class); + return builder.build(); + } + + private Vxlan generateVxlanCorrect() { + return generateVxlanSetFields(true, true, true, true); + } + + private Vxlan generateVxlanMixedIpFamilies() { + return generateVxlan(new IpAddressNoZone(new Ipv6AddressNoZone(IPV6)), + new IpAddressNoZone(new Ipv4AddressNoZone(IPV4_2)), new VniReference(ENCAP), VNI); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java index d2c9ed3a8..206a5a086 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java @@ -38,11 +38,9 @@ import org.mockito.Captor; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.pbb.types.rev161214.Operation; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.PbbRewriteInterfaceAugmentation; import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewrite; -import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewriteBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class PbbRewriteCustomizerTest extends WriterCustomizerTest { @@ -72,14 +70,14 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { @Test public void testWrite() throws WriteFailedException { whenRewriteThenSuccess(); - customizer.writeCurrentAttributes(validId, validData(), writeContext); + customizer.writeCurrentAttributes(validId, PbbRewriteValidatorTest.validData(), writeContext); verifyRewriteRequest(desiredSetResult()); } @Test public void testWriteFailedCallFailed() { whenRewriteThenFail(); - final PbbRewrite validData = validData(); + final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { @@ -96,18 +94,9 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { } @Test - public void testWriteFailedInvalidData() { - verifyInvalidWriteDataCombination(invalidDataNoDestination()); - verifyInvalidWriteDataCombination(invalidDataNoSource()); - verifyInvalidWriteDataCombination(invalidDataNoItag()); - verifyInvalidWriteDataCombination(invalidDataNoOperation()); - verifyInvalidWriteDataCombination(invalidDataNoVlan()); - } - - @Test public void testUpdate() throws WriteFailedException { whenRewriteThenSuccess(); - final PbbRewrite rewrite = validData(); + final PbbRewrite rewrite = PbbRewriteValidatorTest.validData(); customizer.updateCurrentAttributes(validId, rewrite, rewrite, writeContext); verifyRewriteRequest(desiredSetResult()); } @@ -115,8 +104,8 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { @Test public void testUpdateFailedCallFailed() { whenRewriteThenFail(); - final PbbRewrite invalidData = invalidDataNoVlan(); - final PbbRewrite validData = validData(); + final PbbRewrite invalidData = PbbRewriteValidatorTest.invalidDataNoVlan(); + final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.updateCurrentAttributes(validId, invalidData, validData, writeContext); } catch (Exception e) { @@ -134,25 +123,16 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { } @Test - public void testUpdateFailedInvalidData() { - verifyInvalidUpdateDataCombination(invalidDataNoDestination()); - verifyInvalidUpdateDataCombination(invalidDataNoSource()); - verifyInvalidUpdateDataCombination(invalidDataNoItag()); - verifyInvalidUpdateDataCombination(invalidDataNoOperation()); - verifyInvalidUpdateDataCombination(invalidDataNoVlan()); - } - - @Test public void testDelete() throws WriteFailedException { whenRewriteThenSuccess(); - customizer.deleteCurrentAttributes(validId, validData(), writeContext); + customizer.deleteCurrentAttributes(validId, PbbRewriteValidatorTest.validData(), writeContext); verifyRewriteRequest(desiredDisableResult()); } @Test public void testDeleteFailedCallFailed() { whenRewriteThenFail(); - final PbbRewrite validData = validData(); + final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.deleteCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { @@ -165,15 +145,6 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { fail("Test should have failed"); } - @Test - public void testDeleteFailedInvalidData() { - verifyInvalidDeleteDataCombination(invalidDataNoDestination()); - verifyInvalidDeleteDataCombination(invalidDataNoSource()); - verifyInvalidDeleteDataCombination(invalidDataNoItag()); - verifyInvalidDeleteDataCombination(invalidDataNoOperation()); - verifyInvalidDeleteDataCombination(invalidDataNoVlan()); - } - private void whenRewriteThenSuccess() { when(api.l2InterfacePbbTagRewrite(any())).thenReturn(future(new L2InterfacePbbTagRewriteReply())); } @@ -182,41 +153,6 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { when(api.l2InterfacePbbTagRewrite(any())).thenReturn(failedFuture()); } - private void verifyInvalidWriteDataCombination(final PbbRewrite invalidData) { - try { - customizer.writeCurrentAttributes(validId, invalidData, writeContext); - } catch (Exception e) { - assertTrue(e instanceof NullPointerException); - return; - } - - fail("Verifying of invalid combination failed"); - } - - private void verifyInvalidUpdateDataCombination(final PbbRewrite invalidData) { - try { - customizer.updateCurrentAttributes(validId, validData(), invalidData, writeContext); - } catch (Exception e) { - assertTrue(e instanceof NullPointerException); - return; - } - - fail("Verifying of invalid combination failed"); - } - - - private void verifyInvalidDeleteDataCombination(final PbbRewrite invalidData) { - try { - customizer.deleteCurrentAttributes(validId, invalidData, writeContext); - } catch (Exception e) { - assertTrue(e instanceof NullPointerException); - return; - } - - fail("Verifying of invalid combination failed"); - } - - private L2InterfacePbbTagRewrite desiredSetResult() { final L2InterfacePbbTagRewrite desiredResult = new L2InterfacePbbTagRewrite(); desiredResult.swIfIndex = 1; @@ -254,59 +190,4 @@ public class PbbRewriteCustomizerTest extends WriterCustomizerTest { assertArrayEquals(actualRequest.bDmac, desiredResult.bDmac); assertArrayEquals(actualRequest.bSmac, desiredResult.bSmac); } - - private PbbRewrite invalidDataNoDestination() { - return new PbbRewriteBuilder() - .setBVlanTagVlanId(1234) - .setITagIsid(2L) - .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } - - private PbbRewrite invalidDataNoSource() { - return new PbbRewriteBuilder() - .setBVlanTagVlanId(1234) - .setITagIsid(2L) - .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } - - private PbbRewrite invalidDataNoItag() { - return new PbbRewriteBuilder() - .setBVlanTagVlanId(1234) - .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) - .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } - - private PbbRewrite invalidDataNoVlan() { - return new PbbRewriteBuilder() - .setITagIsid(2L) - .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) - .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } - - private PbbRewrite invalidDataNoOperation() { - return new PbbRewriteBuilder() - .setITagIsid(2L) - .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) - .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } - - private PbbRewrite validData() { - return new PbbRewriteBuilder() - .setBVlanTagVlanId(1234) - .setITagIsid(2L) - .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) - .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) - .setInterfaceOperation(Operation.Pop2) - .build(); - } } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidatorTest.java new file mode 100644 index 000000000..114a1bc19 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteValidatorTest.java @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.pbb; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.pbb.types.rev161214.Operation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.PbbRewriteInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewrite; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewriteBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PbbRewriteValidatorTest { + + private PbbRewriteValidator validator; + private InstanceIdentifier<PbbRewrite> validId; + private InstanceIdentifier<PbbRewrite> invalidId; + + @Mock + private WriteContext writeContext; + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new PbbRewriteValidator(ifcContext); + validId = InstanceIdentifier.create(Interfaces.class) + .child(Interface.class, new InterfaceKey("pbb-interface")) + .augmentation(PbbRewriteInterfaceAugmentation.class) + .child(PbbRewrite.class); + + invalidId = InstanceIdentifier.create(PbbRewrite.class); + } + + @Test + public void testWriteSuccessful() + throws CreateValidationFailedException { + validator.validateWrite(validId, validData(), writeContext); + } + + @Test(expected = CreateValidationFailedException.class) + public void testWriteFailedInvalidIID() + throws CreateValidationFailedException { + validator.validateWrite(invalidId, validData(), writeContext); + } + + @Test + public void testWriteFailedInvalidData() { + verifyInvalidWriteDataCombination(invalidDataNoDestination()); + verifyInvalidWriteDataCombination(invalidDataNoSource()); + verifyInvalidWriteDataCombination(invalidDataNoItag()); + verifyInvalidWriteDataCombination(invalidDataNoOperation()); + verifyInvalidWriteDataCombination(invalidDataNoVlan()); + } + + @Test + public void testUpdateFailedInvalidData() { + verifyInvalidUpdateDataCombination(invalidDataNoDestination()); + verifyInvalidUpdateDataCombination(invalidDataNoSource()); + verifyInvalidUpdateDataCombination(invalidDataNoItag()); + verifyInvalidUpdateDataCombination(invalidDataNoOperation()); + verifyInvalidUpdateDataCombination(invalidDataNoVlan()); + } + + @Test + public void testDeleteFailedInvalidData() { + verifyInvalidDeleteDataCombination(invalidDataNoDestination()); + verifyInvalidDeleteDataCombination(invalidDataNoSource()); + verifyInvalidDeleteDataCombination(invalidDataNoItag()); + verifyInvalidDeleteDataCombination(invalidDataNoOperation()); + verifyInvalidDeleteDataCombination(invalidDataNoVlan()); + } + + private void verifyInvalidWriteDataCombination(final PbbRewrite invalidData) { + try { + validator.validateWrite(validId, invalidData, writeContext); + } catch (Exception e) { + assertTrue(e instanceof CreateValidationFailedException); + return; + } + + fail("Verifying of invalid combination failed"); + } + + private void verifyInvalidUpdateDataCombination(final PbbRewrite invalidData) { + try { + validator.validateUpdate(validId, validData(), invalidData, writeContext); + } catch (Exception e) { + assertTrue(e instanceof UpdateValidationFailedException); + return; + } + + fail("Verifying of invalid combination failed"); + } + + private void verifyInvalidDeleteDataCombination(final PbbRewrite invalidData) { + try { + validator.validateDelete(validId, invalidData, writeContext); + } catch (Exception e) { + assertTrue(e instanceof DeleteValidationFailedException); + return; + } + + fail("Verifying of invalid combination failed"); + } + + static PbbRewrite invalidDataNoDestination() { + return new PbbRewriteBuilder() + .setBVlanTagVlanId(1234) + .setITagIsid(2L) + .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } + + static PbbRewrite invalidDataNoSource() { + return new PbbRewriteBuilder() + .setBVlanTagVlanId(1234) + .setITagIsid(2L) + .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } + + static PbbRewrite invalidDataNoItag() { + return new PbbRewriteBuilder() + .setBVlanTagVlanId(1234) + .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) + .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } + + static PbbRewrite invalidDataNoVlan() { + return new PbbRewriteBuilder() + .setITagIsid(2L) + .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) + .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } + + static PbbRewrite invalidDataNoOperation() { + return new PbbRewriteBuilder() + .setITagIsid(2L) + .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) + .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } + + static PbbRewrite validData() { + return new PbbRewriteBuilder() + .setBVlanTagVlanId(1234) + .setITagIsid(2L) + .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa")) + .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb")) + .setInterfaceOperation(Operation.Pop2) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizerTest.java index 9a8ef72ef..e73106a57 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesCustomizerTest.java @@ -110,5 +110,4 @@ public class MirroredInterfacesCustomizerTest extends WriterCustomizerTest { assertEquals(IFACE_INDEX, deleteRequest.swIfIndexTo); assertEquals(SRC_IFACE_INDEX, deleteRequest.swIfIndexFrom); } - } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesValidatorTest.java new file mode 100644 index 000000000..e596c130f --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/span/MirroredInterfacesValidatorTest.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2019 PANTHEON.tech. + * + * 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.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.MockitoAnnotations.initMocks; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.write.DataValidationFailedException; +import io.fd.honeycomb.translate.write.WriteContext; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.SpanState; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.interfaces._interface.Span; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.span.attributes.MirroredInterfaces; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.span.attributes.mirrored.interfaces.MirroredInterface; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190502.span.attributes.mirrored.interfaces.MirroredInterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev180220.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MirroredInterfacesValidatorTest { + + private InstanceIdentifier<MirroredInterface> validId; + private MirroredInterfaceValidator validator; + private static final String IFACE_NAME = "iface"; + private static final String SRC_IFACE_NAME = "src-iface"; + + @Mock + private WriteContext writeContext; + + @Before + public void setUp() { + initMocks(this); + NamingContext ifcContext = new NamingContext("testInterfaceContext", "testInterfaceContext"); + validator = new MirroredInterfaceValidator(ifcContext, id -> id.firstKeyOf(Interface.class).getName()); + validId = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME)) + .augmentation(VppInterfaceAugmentation.class).child(Span.class) + .child(MirroredInterfaces.class) + .child(MirroredInterface.class); + } + + @Test + public void testWriteSuccessful() + throws DataValidationFailedException.CreateValidationFailedException { + validator.validateWrite(validId, validData(), writeContext); + } + + @Test + public void testWriteFailed() { + validateWritingIncorrectData(incorrectDataNoIfaceRef()); + validateWritingIncorrectData(incorrectDataNoSpanState()); + } + + @Test + public void testUpdateSuccessful() + throws DataValidationFailedException.UpdateValidationFailedException { + validator.validateUpdate(validId, validData(), validData(), writeContext); + } + + @Test + public void testDeleteSuccessful() + throws DataValidationFailedException.DeleteValidationFailedException { + validator.validateDelete(validId, validData(), writeContext); + } + + private void validateWritingIncorrectData(final MirroredInterface data) { + try { + validator.validateWrite(validId, data, writeContext); + } catch (DataValidationFailedException.CreateValidationFailedException e) { + assertTrue(e instanceof DataValidationFailedException.CreateValidationFailedException); + return; + } + fail("Verifying of invalid combination failed"); + } + + private MirroredInterface incorrectDataNoIfaceRef() { + return new MirroredInterfaceBuilder() + .setIfaceRef(null) + .setState(SpanState.Receive) + .build(); + } + + private MirroredInterface incorrectDataNoSpanState() { + return new MirroredInterfaceBuilder() + .setIfaceRef(SRC_IFACE_NAME) + .setState(null) + .build(); + } + + private MirroredInterface validData() { + return new MirroredInterfaceBuilder() + .setIfaceRef(SRC_IFACE_NAME) + .setState(SpanState.Receive) + .build(); + } +} diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/VxlanGpeCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/VxlanGpeCustomizerTest.java index 2b89df0bb..e5bd6dc34 100644 --- a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/VxlanGpeCustomizerTest.java +++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfacesstate/VxlanGpeCustomizerTest.java @@ -139,145 +139,3 @@ public class VxlanGpeCustomizerTest extends ReaderCustomizerTest<VxlanGpe, Vxlan return new VxlanGpeCustomizer(api, interfacesContext, dumpCacheManager); } } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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 index da7c8792e..c13775c75 100644 --- 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 @@ -104,7 +104,6 @@ public class MirroredInterfacesCustomizerTest 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 |