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;
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);
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
.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,
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)));
}
}
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;
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,
// 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)
// 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);
}
}
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;
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
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;
--- /dev/null
+/*
+ * 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);
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
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;
}
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,
--- /dev/null
+/*
+ * 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());
+ }
+ }
+}
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
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);
}
@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);
}
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;
- }
}
--- /dev/null
+/*
+ * 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;
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
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;
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
--- /dev/null
+/*
+ * 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
+ }
+}
--- /dev/null
+/*
+ * 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
+ }
+}
--- /dev/null
+/*
+ * 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
+ }
+}
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;
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
--- /dev/null
+/*
+ * 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
+ }
+}
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;
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
// 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) {
--- /dev/null
+/*
+ * 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
+ }
+}
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;
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);
}
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);
}
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;
- }
}
--- /dev/null
+/*
+ * 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;
+ }
+}
--- /dev/null
+/*
+ * 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());
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
--- /dev/null
+/*
+ * 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
+ }
+}
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;
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
--- /dev/null
+/*
+ * 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
+ }
+}
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;
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;
@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();
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);
}
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();
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);
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;
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);
}
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,
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
--- /dev/null
+/*
+ * 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");
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
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;
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
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
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();
}
}
--- /dev/null
+/*
+ * 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");
+ }
+ }
+}
--- /dev/null
+/*
+ * 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");
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
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;
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));
}
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));
}
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();
- }
-
}
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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));
+ }
+}
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;
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 {
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());
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
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();
}
request.twoTags = 1;
request.innerVlanId = innerVlanId;
request.innerVlanIdAny = (byte) (isInnerAny
- ? 1
- : 0);
+ ? 1
+ : 0);
request.dot1Ad = 1;
request.outerVlanId = STAG_ID;
request.exactMatch = 1;
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() {
}
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();
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
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
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");
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;
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;
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;
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());
verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, 4)));
}
-
@Test
public void testWriteIpv6Vrf() throws WriteFailedException {
when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
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)));
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)));
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();
- }
}
--- /dev/null
+/*
+ * 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();
+ }
+}
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() {
protected AbstractUnnumberedCustomizer getCustomizer() {
return new SubInterfaceUnnumberedCustomizer(api, new NamingContext("ifc-prefix", IFC_CTX_NAME));
}
-
}
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
.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);
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
--- /dev/null
+/*
+ * 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);
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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);
+ }
+}
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 {
@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) {
fail("Test should have failed");
}
- @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());
}
@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) {
fail("Test should have failed");
}
- @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) {
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()));
}
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;
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();
- }
}
--- /dev/null
+/*
+ * 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();
+ }
+}
assertEquals(IFACE_INDEX, deleteRequest.swIfIndexTo);
assertEquals(SRC_IFACE_INDEX, deleteRequest.swIfIndexFrom);
}
-
}
--- /dev/null
+/*
+ * 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();
+ }
+}
return new VxlanGpeCustomizer(api, interfacesContext, dumpCacheManager);
}
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
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
Code Review / hc2vpp.git / commitdiff