Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
SubInterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final Routing d1, @Nonnull final WriteContext writeContext) throws WriteFailedException { setRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), routing, writeContext); } SubInterfaceRoutingCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final Routing d1, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); }
@Test 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(); final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)) .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))); } @Test 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(); final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(8L)) .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))); }
SubInterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext) throws WriteFailedException { disableRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), writeContext); } SubInterfaceRoutingCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final Routing d1, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteIpv4Vrf() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build(); customizer.deleteCurrentAttributes(VALID_ID, v4Routing, writeContext); verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, DISABLE_VRF))); } @Test public void testDeleteIpv6Vrf() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing v6Routing = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)).build(); customizer.deleteCurrentAttributes(VALID_ID, v6Routing, writeContext); verifySetTableRequest(1, Collections.singleton(request(true, SUBIF_INDEX, DISABLE_VRF))); }
EthernetCustomizer extends AbstractInterfaceTypeCustomizer<Ethernet> implements JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { setEthernetAttributes(id, dataAfter, writeContext); } EthernetCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeInterface(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { when(api.hwInterfaceSetMtu(any())).thenReturn(future(new HwInterfaceSetMtuReply())); final int mtu = 5678; customizer.updateCurrentAttributes(IF_IID, mock(Ethernet.class), EthernetValidatorTest.ethernet(mtu), writeContext); verify(api).hwInterfaceSetMtu(mtuSetRequest(mtu)); }
EthernetCustomizer extends AbstractInterfaceTypeCustomizer<Ethernet> implements JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException.DeleteFailedException { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Removing ethernet container is not supported")); } EthernetCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeInterface(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IF_IID, mock(Ethernet.class), writeContext); }
AfPacketCustomizer extends AbstractInterfaceTypeCustomizer<AfPacket> implements MacTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteAfPacketIfc(id, swIfName, dataBefore); interfaceContext.removeName(swIfName, writeContext.getMappingContext()); } AfPacketCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { final AfPacket afPacket = afPacket("02:03:04:05:06:07"); final AfPacketDelete expectedDeleteRequest = new AfPacketDelete(); expectedDeleteRequest.hostIfName = IFACE_NAME.getBytes(StandardCharsets.UTF_8); customizer.deleteCurrentAttributes(ID, afPacket, writeContext); verify(api).afPacketDelete(expectedDeleteRequest); verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE))); }
InterfaceValidator implements Validator<Interface> { @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); } } InterfaceValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
InterfaceValidator implements Validator<Interface> { @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); } } InterfaceValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { validator.validateUpdate(ID, getInterface(true), getInterface(true), writeContext); }
FibTableCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Table, TableKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext) throws WriteFailedException { bindFibTableRequest(table).delete(instanceIdentifier); } FibTableCustomizer(@Nonnull final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext); }
@Test public void testDelete(@InjectTestData(resourcePath = "/fib.json", id = FIB_PATH) FibTables tables) throws WriteFailedException { TableKey key = new TableKey(Ipv6.class, new VniReference(0L)); Table data = tables.getTable().stream().filter(table -> table.key().equals(key)).findAny().get(); customizer.deleteCurrentAttributes(FibManagementIIds.FM_FIB_TABLES .child(Table.class, key), data, writeContext); final IpTableAddDel request = new IpTableAddDel(); request.isAdd = 0; request.isIpv6 = 1; request.tableId = 0; request.name = IPV6_VRF_0.getBytes(); verify(api).ipTableAddDel(request); }
InterfaceValidator implements Validator<Interface> { @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); } } InterfaceValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, getInterface(true), writeContext); }
EthernetValidator implements Validator<Ethernet> { @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"); } EthernetValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); }
@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); }
EthernetValidator implements Validator<Ethernet> { @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"); } EthernetValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Ethernet> id, @Nonnull final Ethernet dataBefore, @Nonnull final Ethernet dataAfter, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { validator.validateUpdate(ID, ethernet(IF_MTU), ethernet(IF_MTU + 1), writeContext); }
VhostUserValidator implements Validator<VhostUser> { @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"); } VhostUserValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
VhostUserValidator implements Validator<VhostUser> { @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"); } VhostUserValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws DataValidationFailedException.UpdateValidationFailedException { validator.validateUpdate(ID, getVhostUser(SOCKET), getVhostUser(SOCKET), writeContext); }
VhostUserValidator implements Validator<VhostUser> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { } VhostUserValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteeSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { validator.validateDelete(ID, getVhostUser(SOCKET), writeContext); }
VxlanGpeCustomizer extends AbstractInterfaceTypeCustomizer<VxlanGpe> implements JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteVxlanGpeTunnel(id, swIfName, dataBefore, writeContext); } VxlanGpeCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteCurrentAttributes() throws Exception { final VxlanGpe vxlanGpe = generateVxlanGpe(); whenVxlanGpeAddDelTunnelThenSuccess(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); customizer.deleteCurrentAttributes(id, vxlanGpe, writeContext); verifyVxlanGpeDeleteWasInvoked(vxlanGpe); verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance"))); } @Test public void testDeleteCurrentAttributesaFailed() throws Exception { final VxlanGpe vxlanGpe = generateVxlanGpe(); whenVxlanGpeAddDelTunnelThenFailure(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); try { customizer.deleteCurrentAttributes(id, vxlanGpe, writeContext); } catch (WriteFailedException.DeleteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyVxlanGpeDeleteWasInvoked(vxlanGpe); verify(mappingContext, times(0)).delete(eq(mappingIid(ifaceName, "test-instance"))); return; } fail("WriteFailedException.DeleteFailedException was expected"); }
SubInterfaceUnnumberedValidator implements Validator<Unnumbered> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { checkNotNull(dataAfter.getUse()); } SubInterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
SubInterfaceUnnumberedValidator implements Validator<Unnumbered> { @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()); } SubInterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws DataValidationFailedException.UpdateValidationFailedException { validator.validateUpdate(ID, getUnnumberedIfc(TARGET_IFC0_NAME), getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); }
SubInterfaceUnnumberedValidator implements Validator<Unnumbered> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { checkNotNull(dataBefore.getUse()); } SubInterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteeSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { validator.validateDelete(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); }
SubInterfaceValidator implements Validator<SubInterface> { @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); } } SubInterfaceValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); }
@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); }
InterfaceUnnumberedValidator implements Validator<Unnumbered> { @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"); } InterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
InterfaceUnnumberedValidator implements Validator<Unnumbered> { @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"); } InterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { validator.validateUpdate(ID, getUnnumberedIfc(TARGET_IFC0_NAME), getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); }
RouterAdvertisementsCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ipv6RouterAdvertisements>, JvppReplyConsumer, ByteDataTranslator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Writing RouterAdvertisements {} dataAfter={}", id, dataAfter); setRouterAdvertisements(id, dataAfter, writeContext, false); } RouterAdvertisementsCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite(@InjectTestData(resourcePath = "/ra/simpleRa.json", id = RA_PATH) Interfaces ifc) throws WriteFailedException { final Ipv6RouterAdvertisements data = getRA(ifc); customizer.writeCurrentAttributes(IID, data, writeContext); final SwInterfaceIp6NdRaConfig request = new SwInterfaceIp6NdRaConfig(); request.swIfIndex = IFC_INDEX; request.maxInterval = 600; request.managed = 1; verify(api).swInterfaceIp6NdRaConfig(request); }
InterfaceUnnumberedValidator implements Validator<Unnumbered> { @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"); } InterfaceUnnumberedValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final Unnumbered dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Unnumbered> id, @Nonnull final Unnumbered dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteeSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, getUnnumberedIfc(TARGET_IFC0_NAME), writeContext); }
VxlanValidator implements Validator<Vxlan> { @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); } } VxlanValidator(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager disabledInterfacesManager); @Override void validateWrite(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
VxlanValidator implements Validator<Vxlan> { @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); } } VxlanValidator(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager disabledInterfacesManager); @Override void validateWrite(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, generateVxlanCorrect(), writeContext); }
GreCustomizer extends AbstractInterfaceTypeCustomizer<Gre> implements JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteGreTunnel(id, swIfName, dataBefore, writeContext); } GreCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteCurrentAttributes() throws Exception { final Gre gre = generateGre(); whenGreAddDelTunnelThenSuccess(); defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_TEST_INSTANCE); customizer.deleteCurrentAttributes(id, gre, writeContext); verifyGreDeleteWasInvoked(gre); verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE))); } @Test public void testDeleteCurrentAttributesaFailed() throws Exception { final Gre gre = generateGre(); whenGreAddDelTunnelThenFailure(); defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_TEST_INSTANCE); try { customizer.deleteCurrentAttributes(id, gre, writeContext); } catch (WriteFailedException.DeleteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyGreDeleteWasInvoked(gre); verify(mappingContext, times(0)).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE))); return; } fail("WriteFailedException.DeleteFailedException was expected"); }
RouterAdvertisementsCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ipv6RouterAdvertisements>, JvppReplyConsumer, ByteDataTranslator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Updating RouterAdvertisements {} dataBefore={} dataAfter={}", id, dataBefore, dataAfter); setRouterAdvertisements(id, dataAfter, writeContext, false); } RouterAdvertisementsCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate(@InjectTestData(resourcePath = "/ra/complexRa.json", id = RA_PATH) Interfaces ifc) throws WriteFailedException { final Ipv6RouterAdvertisements data = getRA(ifc); customizer.updateCurrentAttributes(IID, mock(Ipv6RouterAdvertisements.class), data, writeContext); final SwInterfaceIp6NdRaConfig request = new SwInterfaceIp6NdRaConfig(); request.swIfIndex = IFC_INDEX; request.initialCount = 2; request.initialInterval = 15; request.maxInterval = 100; request.minInterval = 20; request.lifetime = 601; request.defaultRouter = 1; verify(api).swInterfaceIp6NdRaConfig(request); }
GreValidator implements Validator<Gre> { @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); } } GreValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
GreValidator implements Validator<Gre> { @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); } } GreValidator(final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, generateCorrectGre(), writeContext); }
VhostUserCustomizer extends AbstractInterfaceTypeCustomizer<VhostUser> implements ByteDataTranslator, JvppReplyConsumer { private void createVhostUserIf(final InstanceIdentifier<VhostUser> id, final String swIfName, final VhostUser vhostUser, final WriteContext writeContext) throws WriteFailedException { LOG.debug("Creating vhost user interface: name={}, vhostUser={}", swIfName, vhostUser); final CompletionStage<CreateVhostUserIfReply> createVhostUserIfReplyCompletionStage = getFutureJVpp().createVhostUserIf(getCreateVhostUserIfRequest(vhostUser)); final CreateVhostUserIfReply reply = getReplyForCreate(createVhostUserIfReplyCompletionStage.toCompletableFuture(), id, vhostUser); LOG.debug("Vhost user interface created successfully for: {}, vhostUser: {}", swIfName, vhostUser); interfaceContext.addName(reply.swIfIndex, swIfName, writeContext.getMappingContext()); } VhostUserCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWriteCurrentAttributes() throws Exception { final VhostUser vhostUser = generateVhostUser(VhostUserRole.Server, "socketName"); when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(future(new CreateVhostUserIfReply())); customizer.writeCurrentAttributes(ID, vhostUser, writeContext); verifyCreateVhostUserIfWasInvoked(vhostUser); verify(mappingContext).put(eq(mappingIid(IFACE_NAME, "test-instance")), eq( mapping(IFACE_NAME, 0).get())); } @Test public void testWriteCurrentAttributesFailed() throws Exception { final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName"); doReturn(failedFuture()).when(api).createVhostUserIf(any(CreateVhostUserIf.class)); try { customizer.writeCurrentAttributes(ID, vhostUser, writeContext); } catch (WriteFailedException.CreateFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyCreateVhostUserIfWasInvoked(vhostUser); verifyZeroInteractions(mappingContext); return; } fail("WriteFailedException.CreateFailedException was expected"); }
VhostUserCustomizer extends AbstractInterfaceTypeCustomizer<VhostUser> implements ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); modifyVhostUserIf(id, swIfName, dataBefore, dataAfter, writeContext); } VhostUserCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateCurrentAttributes() throws Exception { final VhostUser vhostUserBefore = generateVhostUser(VhostUserRole.Client, "socketName0"); final VhostUser vhostUserAfter = generateVhostUser(VhostUserRole.Server, "socketName1"); defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance"); when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(future(new ModifyVhostUserIfReply())); customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext); verifyModifyVhostUserIfWasInvoked(vhostUserAfter, IFACE_ID); }
VhostUserCustomizer extends AbstractInterfaceTypeCustomizer<VhostUser> implements ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteVhostUserIf(id, swIfName, dataBefore, writeContext); } VhostUserCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteCurrentAttributes() throws Exception { final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName"); defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance"); when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(future(new DeleteVhostUserIfReply())); customizer.deleteCurrentAttributes(ID, vhostUser, writeContext); verifyDeleteVhostUserIfWasInvoked(IFACE_ID); verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, "test-instance"))); }
RouterAdvertisementsCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ipv6RouterAdvertisements>, JvppReplyConsumer, ByteDataTranslator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Removing RouterAdvertisements {} dataBefore={}", id, dataBefore); setRouterAdvertisements(id, dataBefore, writeContext, true); } RouterAdvertisementsCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final Ipv6RouterAdvertisements dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv6RouterAdvertisements> id, @Nonnull final Ipv6RouterAdvertisements dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, mock(Ipv6RouterAdvertisements.class), writeContext); final SwInterfaceIp6NdRaConfig request = new SwInterfaceIp6NdRaConfig(); request.swIfIndex = IFC_INDEX; request.suppress = 1; verify(api).swInterfaceIp6NdRaConfig(request); }
L2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifcName = id.firstKeyOf(Interface.class).getName(); final int swIfc = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); setL2(id, swIfc, ifcName, dataAfter, writeContext); } L2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { when(api.swInterfaceSetL2Xconnect(any())).thenReturn(future(new SwInterfaceSetL2XconnectReply())); customizer.writeCurrentAttributes(IID, l2(xconnectBased()), writeContext); verify(api).swInterfaceSetL2Xconnect(xconnectRequest(true)); } @Test public void testWriteFailed() { when(api.swInterfaceSetL2Bridge(any())).thenReturn(failedFuture()); try { customizer.writeCurrentAttributes(IID, l2(bridgeBased(false)), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetL2Bridge(bridgeRequest(false, true)); return; } fail("WriteFailedException expected"); }
L2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifcName = id.firstKeyOf(Interface.class).getName(); final int swIfc = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); setL2(id, swIfc, ifcName, dataAfter, writeContext); } L2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.updateCurrentAttributes(IID, l2(bridgeBased(false)), l2(bridgeBased(true)), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(true, true)); }
L2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifcName = id.firstKeyOf(Interface.class).getName(); final int swIfc = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); deleteL2(id, swIfc, ifcName, dataBefore, writeContext); } L2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { when(api.swInterfaceSetL2Xconnect(any())).thenReturn(future(new SwInterfaceSetL2XconnectReply())); customizer.deleteCurrentAttributes(IID, l2(xconnectBased()), writeContext); verify(api).swInterfaceSetL2Xconnect(xconnectRequest(false)); } @Test public void testDeleteFailed() { when(api.swInterfaceSetL2Bridge(any())).thenReturn(failedFuture()); try { customizer.deleteCurrentAttributes(IID, l2(bridgeBased(true)), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetL2Bridge(bridgeRequest(true, false)); return; } fail("WriteFailedException expected"); }
VxlanGpeValidator implements Validator<VxlanGpe> { @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); } } VxlanGpeValidator(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
ControlPlaneProtocolCustomizer implements ListWriterCustomizer<ControlPlaneProtocol, ControlPlaneProtocolKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ControlPlaneProtocol> instanceIdentifier, @Nonnull final ControlPlaneProtocol routingProtocol, @Nonnull final WriteContext writeContext) throws WriteFailedException { checkIsStatic(routingProtocol); final Long tableId = extractTableId(routingProtocol); final MappingContext mappingContext = writeContext.getMappingContext(); final String newProtocolName = routingProtocol.getName(); synchronized (routingProtocolContext) { if (!routingProtocolContext.containsName(tableId.intValue(), mappingContext)) { if (!isTablePresent(new TableKey(Ipv4.class, new VniReference(tableId)), writeContext) && !isTablePresent(new TableKey(Ipv6.class, new VniReference(tableId)), writeContext)) { throw new WriteFailedException(instanceIdentifier, String.format("VRF lookup table: %s not found for protocol: %s", tableId, instanceIdentifier)); } routingProtocolContext.addName(tableId.intValue(), newProtocolName, mappingContext); } else { if (!newProtocolName.equals(routingProtocolContext.getName(tableId.intValue(), mappingContext))) { throw new IllegalStateException(String.format( "An attempt to assign protocol %s to table id %s. Table id already assigned to protocol %s", newProtocolName, tableId, routingProtocolContext.getName(tableId.intValue(), mappingContext))); } } } } ControlPlaneProtocolCustomizer(@Nonnull final NamingContext routingProtocolContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ControlPlaneProtocol> instanceIdentifier, @Nonnull final ControlPlaneProtocol routingProtocol, @Nonnull final WriteContext writeContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ControlPlaneProtocol> instanceIdentifier, @Nonnull final ControlPlaneProtocol routingProtocol, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void testWriteInvalid() throws WriteFailedException { noMappingDefined(mappingContext, INVALID_TABLE_PROTOCOL_1, "routing-protocol-context"); customizer.writeCurrentAttributes(invalidIid, invalidTableData, writeContext); } @Test public void testWriteIsStatic() throws WriteFailedException { noMappingDefined(mappingContext, ROUTE_PROTOCOL_NAME, "routing-protocol-context"); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { fail("Test should have passed without throwing exception"); } } @Test public void testWriteIsStaticSameAllreadyExist() throws WriteFailedException { defineMapping(mappingContext, ROUTE_PROTOCOL_NAME, 1, "routing-protocol-context"); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { fail("Test should have passed without throwing exception"); } } @Test public void testWriteIsStaticOtherAllreadyExist() throws WriteFailedException { defineMapping(mappingContext, ROUTE_PROTOCOL_NAME, 1, "routing-protocol-context"); try { customizer.writeCurrentAttributes(validId, validData2, writeContext); } catch (Exception e) { assertTrue(e instanceof IllegalStateException); return; } fail("Test should have thrown exception"); } @Test public void testWriteIsntStatic() throws WriteFailedException { try { customizer.writeCurrentAttributes(validId, invalidData, writeContext); } catch (Exception e) { assertTrue(e instanceof IllegalArgumentException); return; } fail("Test should have thrown exception"); }
VxlanGpeValidator implements Validator<VxlanGpe> { @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); } } VxlanGpeValidator(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, generateVxlanCorrect(), writeContext); }
AfPacketValidator implements Validator<AfPacket> { @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); } } AfPacketValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
AfPacketValidator implements Validator<AfPacket> { @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); } } AfPacketValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { validator.validateUpdate(ID, afPacket(IFACE_NAME), afPacket(IFACE_NAME), writeContext); }
AfPacketValidator implements Validator<AfPacket> { @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); } } AfPacketValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, afPacket(IFACE_NAME), writeContext); }
RewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Rewrite>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter, final WriteContext writeContext) throws WriteFailedException { final String subifName = getSubInterfaceName(id); setTagRewrite(id, subifName, dataAfter, writeContext); } RewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter, final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testCreate() throws Exception { final TagRewriteOperation op = TagRewriteOperation.pop_2; final Rewrite vlanTagRewrite = generateRewrite(op); whenL2InterfaceVlanTagRewriteThenSuccess(); customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext); verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op)); } @Test public void testCreateFailed() throws Exception { final TagRewriteOperation op = TagRewriteOperation.pop_2; final Rewrite vlanTagRewrite = generateRewrite(op); whenL2InterfaceVlanTagRewriteThenFailure(); try { customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op)); return; } fail("WriteFailedException.CreateFailedException was expected"); }
RewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Rewrite>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subifName = getSubInterfaceName(id); setTagRewrite(id, subifName, dataAfter, writeContext); } RewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter, final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws Exception { final Rewrite before = generateRewrite(TagRewriteOperation.pop_2); final Rewrite after = generateRewrite(TagRewriteOperation.pop_1); whenL2InterfaceVlanTagRewriteThenSuccess(); customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext); verify(api) .l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1)); } @Test public void testUpdateFailed() throws Exception { final Rewrite before = generateRewrite(TagRewriteOperation.pop_2); final Rewrite after = generateRewrite(TagRewriteOperation.pop_1); whenL2InterfaceVlanTagRewriteThenFailure(); try { customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api) .l2InterfaceVlanTagRewrite( generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1)); return; } fail("WriteFailedException.UpdateFailedException was expected"); }
RewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Rewrite>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subifName = getSubInterfaceName(id); LOG.debug("Disabling tag rewrite for interface {}", subifName); final Rewrite rewrite = new RewriteBuilder().build(); setTagRewrite(id, subifName, rewrite, writeContext); } RewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter, final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws Exception { whenL2InterfaceVlanTagRewriteThenSuccess(); customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext); verifyL2InterfaceVlanTagRewriteDeleteWasInvoked(); } @Test public void testDeleteFailed() throws Exception { whenL2InterfaceVlanTagRewriteThenFailure(); try { customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext); } catch (WriteFailedException e) { Assert.assertTrue(e.getCause() instanceof VppBaseCallException); verifyL2InterfaceVlanTagRewriteDeleteWasInvoked(); return; } fail("WriteFailedException.DeleteFailedException was expected"); }
VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> implements JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteVxlanTunnel(id, swIfName, dataBefore, writeContext); } VxlanCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteCurrentAttributes() throws Exception { final Vxlan vxlan = generateVxlan(); whenVxlanAddDelTunnelThenSuccess(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); customizer.deleteCurrentAttributes(id, vxlan, writeContext); verifyVxlanDeleteWasInvoked(vxlan); verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance"))); verify(disableContext).disableInterface(1, mappingContext); } @Test public void testDeleteCurrentAttributesaFailed() throws Exception { final Vxlan vxlan = generateVxlan(); whenVxlanAddDelTunnelThenFailure(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); try { customizer.deleteCurrentAttributes(id, vxlan, writeContext); } catch (WriteFailedException.DeleteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyVxlanDeleteWasInvoked(vxlan); verify(mappingContext, times(0)).delete(eq(mappingIid(ifaceName, "test-instance"))); return; } fail("WriteFailedException.DeleteFailedException was expected"); }
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); setL2(id, subInterfaceIndex, subInterfaceName, dataAfter, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { final boolean bvi = true; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.writeCurrentAttributes(IID, l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true)); }
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); setL2(id, subInterfaceIndex, subInterfaceName, dataAfter, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { final boolean bvi = false; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.updateCurrentAttributes(IID, l2(true), l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true)); }
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); deleteL2(id, subInterfaceIndex, subInterfaceName, dataBefore, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext, final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { final boolean bvi = true; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.deleteCurrentAttributes(IID, l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, false)); }
SubInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SubInterface, SubInterfaceKey>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String superIfName = id.firstKeyOf(Interface.class).getName(); createSubInterface(id, superIfName, dataAfter, writeContext); } SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testCreateTwoTags() throws Exception { final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200)); final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX); whenCreateSubifThenSuccess(); whenSwInterfaceSetFlagsThenSuccess(); customizer.writeCurrentAttributes(id, subInterface, writeContext); 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())); } @Test public void testCreateDot1qAnyTag() throws Exception { final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_ANY)); final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX); whenCreateSubifThenSuccess(); whenSwInterfaceSetFlagsThenSuccess(); customizer.writeCurrentAttributes(id, subInterface, writeContext); 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())); } @Test public void testCreateFailed() throws Exception { final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200)); final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX); whenCreateSubifThenFailure(); try { customizer.writeCurrentAttributes(id, subInterface, writeContext); } catch (WriteFailedException.CreateFailedException e) { 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())); return; } fail("WriteFailedException.CreateFailedException was expected"); }
SubInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SubInterface, SubInterfaceKey>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subIfaceName = getSubInterfaceName(id.firstKeyOf(Interface.class).getName(), Math.toIntExact(dataAfter.getIdentifier())); setInterfaceState(id, interfaceContext.getIndex(subIfaceName, writeContext.getMappingContext()), booleanToByte(dataAfter.isEnabled())); } SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws Exception { final List<Tag> tags = Arrays.asList(STAG_100, CTAG_200); final SubInterface before = generateSubInterface(false, tags); final SubInterface after = generateSubInterface(true, tags); final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX); whenSwInterfaceSetFlagsThenSuccess(); customizer.updateCurrentAttributes(id, before, after, writeContext); verifySwInterfaceSetFlagsWasInvoked(generateSwInterfaceEnableRequest(SUBIF_INDEX)); }
SubInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SubInterface, SubInterfaceKey>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException.DeleteFailedException { throw new UnsupportedOperationException("Sub interface delete is not supported"); } SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = UnsupportedOperationException.class) public void testDelete() throws Exception { final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200)); customizer.deleteCurrentAttributes(null, subInterface, writeContext); }
PbbRewriteValidator implements Validator<PbbRewrite> { @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); } } PbbRewriteValidator(@Nonnull final NamingContext interfaceNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
PbbRewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<PbbRewrite>, MacTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { setPbbRewrite(id, dataAfter, writeContext, false); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.CreateFailedException(id, dataAfter, e); } } PbbRewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceNamingContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { whenRewriteThenSuccess(); customizer.writeCurrentAttributes(validId, PbbRewriteValidatorTest.validData(), writeContext); verifyRewriteRequest(desiredSetResult()); } @Test public void testWriteFailedCallFailed() { whenRewriteThenFail(); final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException.CreateFailedException); assertTrue(e.getCause() instanceof VppCallbackException); final WriteFailedException.CreateFailedException ex = ((WriteFailedException.CreateFailedException) e); assertEquals(validId, ex.getFailedId()); assertEquals(validData, ex.getData()); return; } fail("Test should have failed"); }
PbbRewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<PbbRewrite>, MacTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { setPbbRewrite(id, dataAfter, writeContext, false); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } PbbRewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceNamingContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { whenRewriteThenSuccess(); final PbbRewrite rewrite = PbbRewriteValidatorTest.validData(); customizer.updateCurrentAttributes(validId, rewrite, rewrite, writeContext); verifyRewriteRequest(desiredSetResult()); } @Test public void testUpdateFailedCallFailed() { whenRewriteThenFail(); final PbbRewrite invalidData = PbbRewriteValidatorTest.invalidDataNoVlan(); final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.updateCurrentAttributes(validId, invalidData, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException.UpdateFailedException); assertTrue(e.getCause() instanceof VppCallbackException); final WriteFailedException.UpdateFailedException ex = ((WriteFailedException.UpdateFailedException) e); assertEquals(validId, ex.getFailedId()); assertEquals(invalidData, ex.getDataBefore()); assertEquals(validData, ex.getDataAfter()); return; } fail("Test should have failed"); }
PbbRewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<PbbRewrite>, MacTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { setPbbRewrite(id, dataBefore, writeContext, true); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } PbbRewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceNamingContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { whenRewriteThenSuccess(); customizer.deleteCurrentAttributes(validId, PbbRewriteValidatorTest.validData(), writeContext); verifyRewriteRequest(desiredDisableResult()); } @Test public void testDeleteFailedCallFailed() { whenRewriteThenFail(); final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.deleteCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException.DeleteFailedException); assertTrue(e.getCause() instanceof VppCallbackException); assertEquals(validId, ((WriteFailedException.DeleteFailedException) e).getFailedId()); return; } fail("Test should have failed"); }
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext) throws WriteFailedException { enableDisableStatistics(statisticsCollection); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { customizer.writeCurrentAttributes(IID, enableStats(true), writeContext); Assert.assertTrue(statsManager.isStatisticsEnabled()); }
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { enableDisableStatistics(dataAfter); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); }
@Test public void testUpdatetoEnabled() throws WriteFailedException { customizer.updateCurrentAttributes(IID, enableStats(true), enableStats(false), writeContext); Assert.assertFalse(statsManager.isStatisticsEnabled()); } @Test public void testUpdateToDisabled() throws WriteFailedException { customizer.updateCurrentAttributes(IID, enableStats(false), enableStats(true), writeContext); Assert.assertTrue(statsManager.isStatisticsEnabled()); }
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext) throws WriteFailedException { statisticsManager.disableStatistics(); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, enableStats(true), writeContext); Assert.assertFalse(statsManager.isStatisticsEnabled()); }
TapV2Customizer extends AbstractInterfaceTypeCustomizer<TapV2> implements MacTranslator, Ipv4Translator, Ipv6Translator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifcName = id.firstKeyOf(Interface.class).getName(); final int index; try { index = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); } catch (IllegalArgumentException e) { throw new WriteFailedException.DeleteFailedException(id, e); } deleteTapV2(id, ifcName, index, dataBefore, writeContext); } TapV2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws Exception { final TapCreateV2Reply t = new TapCreateV2Reply(); t.swIfIndex = 0; doReturn(future(t)).when(api).tapCreateV2(any(TapCreateV2.class)); doReturn(future(new TapDeleteV2Reply())).when(api).tapDeleteV2(any(TapDeleteV2.class)); tapCustomizer.writeCurrentAttributes(getTapId("tap-v2"), getTapData("tap-v2"), writeContext); defineMapping(mappingContext, "tap-v2", 1, IFC_TEST_INSTANCE); tapCustomizer.deleteCurrentAttributes(getTapId("tap-v2"), getTapData("tap-v2"), writeContext); verify(api).tapCreateV2(any(TapCreateV2.class)); verify(api).tapDeleteV2(any(TapDeleteV2.class)); verify(mappingContext).delete(eq(mappingIid("tap-v2", IFC_TEST_INSTANCE))); }
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { setInterface(id, dataAfter, writeContext); } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { final boolean enabled = true; when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply())); customizer.writeCurrentAttributes(IID, iface(enabled), writeContext); verify(api).swInterfaceSetFlags(expectedRequest(enabled)); } @Test public void testWriteFailed() { final boolean enabled = false; when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture()); try { customizer.writeCurrentAttributes(IID, iface(enabled), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetFlags(expectedRequest(enabled)); return; } fail("WriteFailedException expected"); }
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { updateInterface(id, dataAfter, writeContext); } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply())); customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext); verify(api).swInterfaceSetFlags(expectedRequest(true)); } @Test public void testUpdateFailed() { when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture()); try { customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetFlags(expectedRequest(true)); return; } fail("WriteFailedException expected"); }
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException.DeleteFailedException { if (LOCAL0_NAME.equals(dataBefore.getName())) { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Removing " + LOCAL0_NAME + " interface is not supported")); } } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, mock(Interface.class), writeContext); verifyZeroInteractions(api); } @Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteLocal0() throws WriteFailedException { final Interface ifc = mock(Interface.class); when(ifc.getName()).thenReturn(LOCAL0_IFC_NAME); customizer.deleteCurrentAttributes(LOCAL0_IID, ifc, writeContext); }
InterfaceRoutingValidator implements Validator<Routing> { @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); } } InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
InterfaceRoutingValidator implements Validator<Routing> { @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); } } InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext 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); }
InterfaceRoutingValidator implements Validator<Routing> { @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); } } InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext 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); }
Ipv4RouteCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Route, RouteKey>, JvppReplyConsumer, RouteMapper { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String parentProtocolName = instanceIdentifier.firstKeyOf(ControlPlaneProtocol.class).getName(); final String routeName = routeNamesFactory.uniqueRouteName(parentProtocolName, route); Optional<ControlPlaneProtocol> protocolOptional = writeContext.readAfter(RWUtils.cutId(instanceIdentifier, ControlPlaneProtocol.class)); Preconditions.checkArgument(protocolOptional.isPresent(), "Control protocol cannot be null for route: {}", instanceIdentifier); TableKey key = new TableKey( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.Ipv4.class, new VniReference(ControlPlaneProtocolCustomizer.extractTableId(protocolOptional.get()))); if (!ControlPlaneProtocolCustomizer.isTablePresent(key, writeContext)) { throw new WriteFailedException(instanceIdentifier, "IPv4 FIB table does not exist!"); } writeRoute(instanceIdentifier, parentProtocolName, routeName, route, writeContext, true); routesContext.addName(routeName, writeContext.getMappingContext()); } Ipv4RouteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext, @Nonnull final NamingContext routesContext, @Nonnull final NamingContext routingProtocolContext, @Nonnull final MultiNamingContext routesHopsContext, @Nonnull final VppClassifierContextManager classifierContextManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route routeBefore, @Nonnull final Route routeAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void testWriteSingleHopInvalid( @InjectTestData(resourcePath = "/ipv4/simplehop/simpleHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { final Route route1 = getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_INVALID_NAME, route1), "route-context"); customizer.writeCurrentAttributes(ROUTE_INVALID_IID, route1, writeContext); verifyInvocation(0, ImmutableList.of(), api, requestCaptor); } @Test public void testWriteSingleHop( @InjectTestData(resourcePath = "/ipv4/simplehop/simpleHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { final Route route1 = getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route1), "route-context"); customizer.writeCurrentAttributes(ROUTE_IID, route1, writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(1, 0, 0, FIRST_ADDRESS_AS_ARRAY, 24, SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 0, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); } @Test public void testWriteTableLookup() throws WriteFailedException { final Route route = new RouteBuilder() .withKey(new RouteKey(new Ipv4Prefix("192.168.2.1/24"))) .setDestinationPrefix(new Ipv4Prefix("192.168.2.1/24")) .setNextHop(new NextHopBuilder().setNextHopOptions( new TableLookupCaseBuilder() .setSecondaryVrf(new VniReference(4L)) .setAddressFamily( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.Ipv4.class) .build()).build()) .build(); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route), "route-context"); customizer.writeCurrentAttributes(ROUTE_IID, route, writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(1, 0, 0, FIRST_ADDRESS_AS_ARRAY, 24, new byte[4], ~0, 0, TABLE_ID.intValue(), 4, 0, 0)), api, requestCaptor); } @Test public void testWriteHopList( @InjectTestData(resourcePath = "/ipv4/multihop/multiHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { final Route route1 = getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route1), "route-context"); customizer.writeCurrentAttributes(ROUTE_IID, route1, writeContext); verifyInvocation(2, ImmutableList.of( desiredFlaglessResult(1, 0, 1, FIRST_ADDRESS_AS_ARRAY, 24, FIRST_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 2, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1), desiredFlaglessResult(1, 0, 1, FIRST_ADDRESS_AS_ARRAY, 24, SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 3, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); verify(routeHopContext, times(1)) .addChild( namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route1), 1, namesFactory.uniqueRouteHopName(getHopWithId(route1, 1)), mappingContext); verify(routeHopContext, times(1)) .addChild( namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route1), 2, namesFactory.uniqueRouteHopName(getHopWithId(route1, 2)), mappingContext); } @Test public void testWriteSpecialHop( @InjectTestData(resourcePath = "/ipv4/specialhop/specialHopRouteBlackhole.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { final Route route1 = getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route1), "route-context"); customizer.writeCurrentAttributes(ROUTE_IID, route1, writeContext); verifyInvocation(1, ImmutableList .of(desiredSpecialResult(1, 0, FIRST_ADDRESS_AS_ARRAY, 24, 1, 0, 0, 0, TABLE_ID.intValue(), 0)), api, requestCaptor); }
FibTableCustomizer implements InitializingListReaderCustomizer<Table, TableKey, TableBuilder>, ByteDataTranslator { @Nonnull @Override public List<TableKey> getAllIds(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final ReadContext readContext) throws ReadFailedException { return Stream.concat(ipv4DumpManager.getDump(instanceIdentifier, readContext.getModificationCache()) .orElse(new IpFibDetailsReplyDump()) .ipFibDetails.stream() .filter(ipFibDetails -> ipFibDetails.tableId >= 0) .map(ipFibDetails -> new TableKey(Ipv4.class, new VniReference((long) ipFibDetails.tableId))) .distinct(), ipv6DumpManager.getDump(instanceIdentifier, readContext.getModificationCache()) .orElse(new Ip6FibDetailsReplyDump()) .ip6FibDetails.stream() .filter(ip6FibDetails -> ip6FibDetails.tableId >= 0) .map(ipFibDetails -> new TableKey(Ipv6.class, new VniReference((long) ipFibDetails.tableId)))) .distinct() .collect(Collectors.toList()); } FibTableCustomizer(final DumpCacheManager<IpFibDetailsReplyDump, Void> ipv4DumpManager, final DumpCacheManager<Ip6FibDetailsReplyDump, Void> ipv6DumpManager); @Nonnull @Override List<TableKey> getAllIds(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final ReadContext readContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Table> list); @Nonnull @Override TableBuilder getBuilder(@Nonnull final InstanceIdentifier<Table> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final TableBuilder builder, @Nonnull final ReadContext readContext); @Nonnull @Override Initialized<Table> init(@Nonnull final InstanceIdentifier<Table> id, @Nonnull final Table readValue, @Nonnull final ReadContext ctx); }
@Test public void getAllIds() throws Exception { final List<TableKey> keys = getCustomizer().getAllIds(TABLE_V6_ID, ctx); assertThat(keys, hasSize(2)); assertThat(keys, hasItems(new TableKey(Ipv6.class, new VniReference(1L)), new TableKey(Ipv4.class, new VniReference(1L)))); }
LoopbackCustomizer extends AbstractInterfaceTypeCustomizer<Loopback> implements MacTranslator, JvppReplyConsumer { private void createLoopback(final InstanceIdentifier<Loopback> id, final String swIfName, final Loopback loopback, final WriteContext writeContext) throws WriteFailedException { LOG.debug("Setting loopback interface: {}. Loopback: {}", swIfName, loopback); final CreateLoopback createLoopback = new CreateLoopback(); if (loopback.getMac() != null) { createLoopback.macAddress = parseMac(loopback.getMac().getValue()); } final CreateLoopbackReply reply = getReplyForCreate(getFutureJVpp().createLoopback(createLoopback).toCompletableFuture(), id, loopback); LOG.debug("Loopback set successfully for: {}, loopback: {}", swIfName, loopback); interfaceContext.addName(reply.swIfIndex, swIfName, writeContext.getMappingContext()); } LoopbackCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Loopback> id, @Nonnull final Loopback dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testCreate() throws Exception { doAnswer(new Answer() { int idx = 0; @Override public Object answer(final InvocationOnMock invocation) throws Throwable { final CreateLoopbackReply t = new CreateLoopbackReply(); t.swIfIndex = idx++; return future(t); } }).when(api).createLoopback(any(CreateLoopback.class)); loopCustomizer.writeCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); loopCustomizer.writeCurrentAttributes(getLoopbackId("loop2"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); verify(api, times(2)).createLoopback(any(CreateLoopback.class)); verify(mappingContext).put(eq(mappingIid("loop", IFC_TEST_INSTANCE)), eq( mapping("loop", 0).get())); verify(mappingContext).put(eq(mappingIid("loop2", IFC_TEST_INSTANCE)), eq( mapping("loop2", 1).get())); }
InterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifName = id.firstKeyOf(Interface.class).getName(); setRouting(id, ifName, dataAfter, writeContext); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final int vrfId = 123; when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply())); customizer.writeCurrentAttributes(IID, routing(vrfId), writeContext); verify(api).swInterfaceSetTable(expectedRequest(vrfId)); } @Test(expected = WriteFailedException.class) public void testWriteFailed() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(failedFuture()); customizer.writeCurrentAttributes(IID, routing(213), writeContext); } @Test public void testWriteEmptyIfaceData() throws WriteFailedException { 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)); }
InterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifName = id.firstKeyOf(Interface.class).getName(); setRouting(id, ifName, dataAfter, writeContext); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void testUpdateFailed() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(failedFuture()); customizer.updateCurrentAttributes(IID, routing(123L), routing(321L), writeContext); }
InterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifName = id.firstKeyOf(Interface.class).getName(); disableRouting(id, ifName, writeContext); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply())); customizer.deleteCurrentAttributes(IID, routing(123), writeContext); verify(api).swInterfaceSetTable(expectedRequest(0)); } @Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteFailed() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(failedFuture()); customizer.deleteCurrentAttributes(IID, routing(123), writeContext); }
SubInterfaceRoutingValidator implements Validator<Routing> { @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); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@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); }
SubInterfaceRoutingValidator implements Validator<Routing> { @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); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateUpdate(ID, getRouting(), getRouting(), writeContext); }
SubInterfaceRoutingValidator implements Validator<Routing> { @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); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateDelete(ID, getRouting(), writeContext); }
DisabledInterfacesManager { public List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx) { final Optional<DisabledInterfaces> read = ctx.read(DISABLED_IFCS_ROOT); if (read.isPresent()) { return read.get().getDisabledInterfaceIndex().stream() .map(DisabledInterfaceIndex::getIndex) .collect(Collectors.toList()); } else { return Collections.emptyList(); } } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }
@Test public void testGetAll() throws Exception { final List<Integer> disabledInterfaces = manager.getDisabledInterfaces(mappingContext); assertThat(disabledInterfaces, hasItems(1, 2, 3)); }
DisabledInterfacesManager { public boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx) { return ctx.read(getKeyedId(index)) .isPresent(); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }
@Test public void testCheckOne() throws Exception { assertTrue(manager.isInterfaceDisabled(1, mappingContext)); assertFalse(manager.isInterfaceDisabled(4, mappingContext)); }
DisabledInterfacesManager { public void disableInterface(final int index, @Nonnull final MappingContext ctx) { ctx.put(getKeyedId(index), getDisabledInterfaceIndex(index)); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }
@Test public void testDisable() throws Exception { manager.disableInterface(1, mappingContext); verify(mappingContext).put(SPECIFIC_ID_1, toIndex(1)); }
DisabledInterfacesManager { public void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx) { ctx.delete(getKeyedId(index)); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }
@Test public void testRemoveDisability() throws Exception { manager.removeDisabledInterface(1, mappingContext); verify(mappingContext).delete(SPECIFIC_ID_1); }
InterfaceChangeNotificationProducer implements ManagedNotificationProducer, JvppReplyConsumer { @Override public void start(@Nonnull final NotificationCollector collector) { LOG.trace("Starting interface notifications"); enableDisableIfcNotifications(1); LOG.debug("Interface notifications started successfully"); notificationListenerReg = jvpp.getEventRegistry().registerSwInterfaceEventCallback( new SwInterfaceEventCallback() { @Override public void onSwInterfaceEvent(SwInterfaceEvent swInterfaceEvent) { LOG.trace("Interface notification received: {}", swInterfaceEvent); try { collector.onNotification(transformNotification(swInterfaceEvent)); } catch (Exception e) { LOG.warn("Failed to process interface notification {}", swInterfaceEvent, e); } } @Override public void onError(VppCallbackException e) { } } ); } @Inject InterfaceChangeNotificationProducer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final MappingContext mappingContext); @Override void start(@Nonnull final NotificationCollector collector); @Override void stop(); @Nonnull @Override Collection<Class<? extends Notification>> getNotificationTypes(); @Override void close(); }
@Test public void testStart() throws Exception { final InterfaceChangeNotificationProducer interfaceChangeNotificationProducer = new InterfaceChangeNotificationProducer(jVpp, namingContext, mappingContext); interfaceChangeNotificationProducer.start(collector); verify(jVpp).wantInterfaceEvents(any(WantInterfaceEvents.class)); verify(jVpp).getEventRegistry(); verify(notificationRegistry).registerSwInterfaceEventCallback(any( SwInterfaceEventCallback.class)); interfaceChangeNotificationProducer.stop(); verify(jVpp, times(2)).wantInterfaceEvents(any(WantInterfaceEvents.class)); verify(notificationListenerReg).close(); } @Test public void testNotification() throws Exception { final InterfaceChangeNotificationProducer interfaceChangeNotificationProducer = new InterfaceChangeNotificationProducer(jVpp, namingContext, mappingContext); interfaceChangeNotificationProducer.start(collector); final SwInterfaceEvent swInterfaceSetFlagsNotification = new SwInterfaceEvent(); swInterfaceSetFlagsNotification.deleted = 0; swInterfaceSetFlagsNotification.swIfIndex = IFACE_ID; swInterfaceSetFlagsNotification.adminUpDown = 1; swInterfaceSetFlagsNotification.linkUpDown = 1; callbackArgumentCaptor.getValue().onSwInterfaceEvent(swInterfaceSetFlagsNotification); final ArgumentCaptor<InterfaceChange> notificationCaptor = ArgumentCaptor.forClass(InterfaceChange.class); verify(collector).onNotification(notificationCaptor.capture()); assertEquals(IFACE_NAME, notificationCaptor.getValue().getName().getString()); assertEquals(InterfaceStatus.Up, notificationCaptor.getValue().getAdminStatus()); assertEquals(InterfaceStatus.Up, notificationCaptor.getValue().getOperStatus()); }
SubInterfaceRoutingCustomizer extends RoutingCustomizer implements InitializingReaderCustomizer<Routing, RoutingBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final RoutingBuilder routingBuilder, @Nonnull final ReadContext readContext) throws ReadFailedException { readInterfaceRouting(instanceIdentifier, routingBuilder::setIpv4VrfId, routingBuilder::setIpv6VrfId, readContext, subInterfaceFullNameOperational(instanceIdentifier)); } SubInterfaceRoutingCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final ReadContext readContext); @Nonnull @Override RoutingBuilder getBuilder(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final RoutingBuilder routingBuilder, @Nonnull final ReadContext readContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final Routing routing); }
@Test public void testReadAttributesAllDefined() throws ReadFailedException { when(api.swInterfaceGetTable(request(false, SUBIF_ID))).thenReturn(future(reply(IPV4_VRF))); when(api.swInterfaceGetTable(request(true, SUBIF_ID))).thenReturn(future(reply(IPV6_VRF))); final RoutingBuilder routingBuilder = new RoutingBuilder(); getCustomizer().readCurrentAttributes(VALID_ID, routingBuilder, ctx); assertEquals(IPV4_VRF, routingBuilder.getIpv4VrfId().getValue().intValue()); assertEquals(IPV6_VRF, routingBuilder.getIpv6VrfId().getValue().intValue()); } @Test public void testReadAttributesOneDefined() throws ReadFailedException { when(api.swInterfaceGetTable(request(false, SUBIF_ID))).thenReturn(future(reply(IPV4_VRF))); when(api.swInterfaceGetTable(request(true, SUBIF_ID))).thenReturn(future(reply(NO_VRF))); final RoutingBuilder routingBuilder = new RoutingBuilder(); getCustomizer().readCurrentAttributes(VALID_ID, routingBuilder, ctx); assertEquals(IPV4_VRF, routingBuilder.getIpv4VrfId().getValue().intValue()); assertNull(routingBuilder.getIpv6VrfId()); } @Test public void testReadAttributesNoDefined() throws ReadFailedException { when(api.swInterfaceGetTable(any())).thenReturn(future(reply(NO_VRF))); final RoutingBuilder routingBuilder = new RoutingBuilder(); getCustomizer().readCurrentAttributes(VALID_ID, routingBuilder, ctx); assertNull(routingBuilder.getIpv4VrfId()); assertNull(routingBuilder.getIpv6VrfId()); }
AfPacketCustomizer implements InitializingReaderCustomizer<AfPacket, AfPacketBuilder>, InterfaceDataTranslator, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacketBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); final SwInterfaceDetails ifcDetails = dumpManager.getInterfaceDetail(id, ctx, key.getName()); if (!isInterfaceOfType( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190527.AfPacket.class, ifcDetails)) { return; } final AfPacketDetailsReplyDump dump = afPacketDumpManager.getDump(id, ctx.getModificationCache()) .orElse(new AfPacketDetailsReplyDump()); final AfPacketDetails afPacketDetails = dump.afPacketDetails.stream() .filter(detail -> detail.swIfIndex == index) .findFirst() .orElseThrow(() -> new IllegalArgumentException(format("AfPacket interface %s not found", key.getName()))); LOG.trace("AfPacket interface: {} attributes returned from VPP: {}", key.getName(), afPacketDetails); builder.setMac(new PhysAddress(vppPhysAddrToYang(ifcDetails.l2Address))); builder.setHostInterfaceName(toString(afPacketDetails.hostIfName)); LOG.debug("AfPacket interface: {}, id: {} attributes read as: {}", key.getName(), index, builder); } AfPacketCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull AfPacket readValue); @Nonnull @Override AfPacketBuilder getBuilder(@Nonnull InstanceIdentifier<AfPacket> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacketBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<AfPacket> init(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws ReadFailedException { final AfPacketBuilder builder = mock(AfPacketBuilder.class); when(dumpCacheManager.getInterfaceDetail(IID, ctx, IF_NAME)).thenReturn(ifaceDetails()); when(api.afPacketDump(any())).thenReturn(future(afPacketReplyDump())); getCustomizer().readCurrentAttributes(IID, builder, ctx); verify(builder).setMac(new PhysAddress("01:02:03:04:05:06")); } @Test public void testReadFailed() throws ReadFailedException { final AfPacketBuilder builder = mock(AfPacketBuilder.class); when(dumpCacheManager.getInterfaceDetail(IID, ctx, IF_NAME)).thenReturn(null); getCustomizer().readCurrentAttributes(IID, builder, ctx); verifyZeroInteractions(builder); }
AfPacketCustomizer implements InitializingReaderCustomizer<AfPacket, AfPacketBuilder>, InterfaceDataTranslator, JvppReplyConsumer { @Nonnull @Override public Initialized<AfPacket> init(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket readValue, @Nonnull final ReadContext ctx) { return Initialized.create(getCfgId(id), new AfPacketBuilder() .setHostInterfaceName(readValue.getHostInterfaceName()) .setMac(readValue.getMac()) .build()); } AfPacketCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull AfPacket readValue); @Nonnull @Override AfPacketBuilder getBuilder(@Nonnull InstanceIdentifier<AfPacket> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacketBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<AfPacket> init(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket readValue, @Nonnull final ReadContext ctx); }
@Test public void testInit() { final AfPacket operData = new AfPacketBuilder() .setHostInterfaceName(IF_NAME) .setMac(new PhysAddress("11:22:33:44:55:66")).build(); final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190527.interfaces._interface.AfPacket cfgData = new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190527.interfaces._interface.AfPacketBuilder() .setHostInterfaceName(IF_NAME) .setMac(new PhysAddress("11:22:33:44:55:66")).build(); invokeInitTest(IID, operData, getCfgId(IID), cfgData); }
VxlanGpeCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VxlanGpe, VxlanGpeBuilder>, InterfaceDataTranslator, JvppReplyConsumer, Ipv4Translator, Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpeBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); if (!isInterfaceOfType(dumpManager, id, ctx, VxlanGpeTunnel.class)) { return; } LOG.debug("Reading attributes for VxlanGpe tunnel: {}", key.getName()); final VxlanGpeTunnelDump request = new VxlanGpeTunnelDump(); request.swIfIndex = index; final CompletionStage<VxlanGpeTunnelDetailsReplyDump> swInterfaceVxlanGpeDetailsReplyDumpCompletionStage = getFutureJVpp().vxlanGpeTunnelDump(request); final VxlanGpeTunnelDetailsReplyDump reply = getReplyForRead(swInterfaceVxlanGpeDetailsReplyDumpCompletionStage.toCompletableFuture(), id); if (reply == null || reply.vxlanGpeTunnelDetails == null || reply.vxlanGpeTunnelDetails.isEmpty()) { LOG.debug( "VxlanGpe tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" + "after delete", key.getName(), index); return; } checkState(reply.vxlanGpeTunnelDetails.size() == 1, "Unexpected number of returned VxlanGpe tunnels: {} for tunnel: {}", reply.vxlanGpeTunnelDetails, key.getName()); LOG.trace("VxlanGpe tunnel: {} attributes returned from VPP: {}", key.getName(), reply); final VxlanGpeTunnelDetails swInterfaceVxlanGpeDetails = reply.vxlanGpeTunnelDetails.get(0); if (swInterfaceVxlanGpeDetails.isIpv6 == 1) { builder.setRemote(new IpAddressNoZone(arrayToIpv6AddressNoZone(swInterfaceVxlanGpeDetails.remote))); builder.setLocal(new IpAddressNoZone(arrayToIpv6AddressNoZone(swInterfaceVxlanGpeDetails.local))); } else { builder.setRemote(new IpAddressNoZone(arrayToIpv4AddressNoZone(swInterfaceVxlanGpeDetails.remote))); builder.setLocal(new IpAddressNoZone(arrayToIpv4AddressNoZone(swInterfaceVxlanGpeDetails.local))); } builder.setVni(new VxlanGpeVni((long) swInterfaceVxlanGpeDetails.vni)); builder.setNextProtocol(VxlanGpeNextProtocol.forValue(swInterfaceVxlanGpeDetails.protocol)); builder.setEncapVrfId((long) swInterfaceVxlanGpeDetails.encapVrfId); builder.setDecapVrfId((long) swInterfaceVxlanGpeDetails.decapVrfId); LOG.debug("VxlanGpe tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder); } VxlanGpeCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull VxlanGpe readValue); @Nonnull @Override VxlanGpeBuilder getBuilder(@Nonnull InstanceIdentifier<VxlanGpe> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpeBuilder builder, @Nonnull final ReadContext ctx); @Override Initialized<VxlanGpe> init(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadCurrentAttributes() throws Exception { final VxlanGpeBuilder builder = getCustomizer().getBuilder(VXLAN_GPE_ID); getCustomizer().readCurrentAttributes(VXLAN_GPE_ID, builder, ctx); assertNull(builder.getLocal().getIpv6AddressNoZone()); assertNotNull(builder.getLocal().getIpv4AddressNoZone()); assertEquals("1.2.3.4", builder.getLocal().getIpv4AddressNoZone().getValue()); assertNull(builder.getRemote().getIpv6AddressNoZone()); assertNotNull(builder.getRemote().getIpv4AddressNoZone()); assertEquals("1.2.3.5", builder.getRemote().getIpv4AddressNoZone().getValue()); assertEquals(9, builder.getVni().getValue().intValue()); assertEquals(1, builder.getNextProtocol().getIntValue()); assertEquals(55, builder.getEncapVrfId().intValue()); assertEquals(66, builder.getDecapVrfId().intValue()); verify(api).vxlanGpeTunnelDump(any(VxlanGpeTunnelDump.class)); }
InterfaceStatisticsCustomizer implements ReaderCustomizer<Statistics, StatisticsBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final StatisticsBuilder statisticsBuilder, @Nonnull final ReadContext readContext) throws ReadFailedException { if (!statisticsManager.isStatisticsEnabled()) return; final InterfaceKey key = instanceIdentifier.firstKeyOf(Interface.class); final int index = ifcNamingCtx.getIndex(key.getName(), readContext.getMappingContext()); InterfaceStatisticsDetails stats = getStatisticsDump(instanceIdentifier); if (stats != null) { Optional<InterfaceStatistics> statsDetail = Arrays.asList(stats.interfaceStatistics).stream().filter(elt -> elt.swIfIndex == index).findFirst(); if (statsDetail.isPresent()) { InterfaceStatistics detail = statsDetail.get(); statisticsBuilder.setOutOctets(new Counter64(BigInteger.valueOf(detail.outBytes))) .setOutUnicastPkts(new Counter64(BigInteger.valueOf(detail.outUnicastPkts))) .setOutMulticastPkts(new Counter64(BigInteger.valueOf(detail.outMulticastPkts))) .setOutBroadcastPkts(new Counter64(BigInteger.valueOf(detail.outBroadcastPkts))) .setOutErrors(new Counter32(new Long(detail.outErrors))) .setInOctets(new Counter64(BigInteger.valueOf(detail.inBytes))) .setInUnicastPkts(new Counter64(BigInteger.valueOf(detail.inUnicastPkts))) .setInMulticastPkts(new Counter64(BigInteger.valueOf(detail.inMulticastPkts))) .setInBroadcastPkts(new Counter64(BigInteger.valueOf(detail.inBroadcastPkts))) .setInErrors(new Counter32(new Long(detail.inErrors))); } } } InterfaceStatisticsCustomizer(final NamingContext ifcNamingCtx, final FutureJVppStatsFacade jvppStats, final InterfaceStatisticsManager statisticsManager); @Nonnull @Override StatisticsBuilder getBuilder(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final StatisticsBuilder statisticsBuilder, @Nonnull final ReadContext readContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final Statistics statistics); }
@Test public void testReadStatistics() throws Exception { statisticsManager.enableStatistics(); when(ctx.getMappingContext().read(any())) .thenReturn(Optional.of(new MappingBuilder().setName(IF_NAME).setIndex(SW_IF_INDEX).build())); when(jvppStats.interfaceStatisticsDump(any())).thenReturn(future(getStatistics())); StatisticsBuilder statBuilder = new StatisticsBuilder(); getCustomizer().readCurrentAttributes(IID, statBuilder, ctx); Statistics stat = statBuilder.build(); int[] expected = new int[]{SW_IF_INDEX, OUT_ERRORS, OUT_MULTI, OUT_UNI, OUT_BROAD, OUT_BYTES, IN_ERRORS, IN_MULTI, IN_UNI, IN_BROAD, IN_BYTES}; int[] actual = new int[]{interfaceContext.getIndex(IF_NAME, ctx.getMappingContext()), stat.getOutErrors().getValue().intValue(), stat.getOutMulticastPkts().getValue().intValue(), stat.getOutUnicastPkts().getValue().intValue(), stat.getOutBroadcastPkts().getValue().intValue(), stat.getOutOctets().getValue().intValue(), stat.getInErrors().getValue().intValue(), stat.getInMulticastPkts().getValue().intValue(), stat.getInUnicastPkts().getValue().intValue(), stat.getInBroadcastPkts().getValue().intValue(), stat.getInOctets().getValue().intValue()}; Assert.assertArrayEquals(expected, actual); } @Test(expected = ReadFailedException.class) public void testReadStatisticsFailed() throws Exception { statisticsManager.enableStatistics(); when(ctx.getMappingContext().read(any())) .thenReturn(Optional.of(new MappingBuilder().setName(IF_NAME).setIndex(SW_IF_INDEX).build())); when(jvppStats.interfaceStatisticsDump(any())).thenReturn(future(null)); StatisticsBuilder statBuilder = new StatisticsBuilder(); getCustomizer().readCurrentAttributes(IID, statBuilder, ctx); }
GreCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<Gre, GreBuilder>, InterfaceDataTranslator, Ipv4Translator, Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final GreBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); if (!isInterfaceOfType(dumpManager, id, ctx, GreTunnel.class)) { return; } LOG.debug("Reading attributes for gre tunnel: {}", key.getName()); final GreTunnelDump request = new GreTunnelDump(); request.swIfIndex = new InterfaceIndex(); request.swIfIndex.interfaceindex = index; final CompletionStage<GreTunnelDetailsReplyDump> swInterfaceGreDetailsReplyDumpCompletionStage = getFutureJVpp().greTunnelDump(request); final GreTunnelDetailsReplyDump reply = getReplyForRead(swInterfaceGreDetailsReplyDumpCompletionStage.toCompletableFuture(), id); if (reply == null || reply.greTunnelDetails == null || reply.greTunnelDetails.isEmpty()) { LOG.debug( "Gre tunnel {}, id {} has no attributes assigned in VPP. Probably is a leftover interface placeholder" + "after delete", key.getName(), index); return; } checkState(reply.greTunnelDetails.size() == 1, "Unexpected number of returned gre tunnels: {} for tunnel: {}", reply.greTunnelDetails, key.getName()); LOG.trace("Gre tunnel: {} attributes returned from VPP: {}", key.getName(), reply); final GreTunnelDetails swInterfaceGreDetails = reply.greTunnelDetails.get(0); if (swInterfaceGreDetails.tunnel.dst.af.equals(AddressFamily.ADDRESS_IP6)) { builder.setDst(new IpAddressNoZone( arrayToIpv6AddressNoZone(swInterfaceGreDetails.tunnel.dst.un.getIp6().ip6Address))); builder.setSrc(new IpAddressNoZone( arrayToIpv6AddressNoZone(swInterfaceGreDetails.tunnel.src.un.getIp6().ip6Address))); } else { builder.setDst(new IpAddressNoZone( arrayToIpv4AddressNoZone(swInterfaceGreDetails.tunnel.dst.un.getIp4().ip4Address))); builder.setSrc(new IpAddressNoZone( arrayToIpv4AddressNoZone(swInterfaceGreDetails.tunnel.src.un.getIp4().ip4Address))); } builder.setOuterFibId((long) swInterfaceGreDetails.tunnel.outerFibId); LOG.debug("Gre tunnel: {}, id: {} attributes read as: {}", key.getName(), index, builder); } GreCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull Gre readValue); @Nonnull @Override GreBuilder getBuilder(@Nonnull InstanceIdentifier<Gre> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final GreBuilder builder, @Nonnull final ReadContext ctx); @Override @Nonnull Initialized<Gre> init(@Nonnull final InstanceIdentifier<Gre> id, @Nonnull final Gre readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadCurrentAttributes() throws Exception { final GreBuilder builder = getCustomizer().getBuilder(IID); getCustomizer().readCurrentAttributes(IID, builder, ctx); assertEquals(55, builder.getOuterFibId().intValue()); assertNull(builder.getSrc().getIpv6AddressNoZone()); assertNotNull(builder.getSrc().getIpv4AddressNoZone()); assertEquals("1.2.3.5", builder.getSrc().getIpv4AddressNoZone().getValue()); assertNull(builder.getDst().getIpv6AddressNoZone()); assertNotNull(builder.getDst().getIpv4AddressNoZone()); assertEquals("1.2.3.4", builder.getDst().getIpv4AddressNoZone().getValue()); verify(api).greTunnelDump(any(GreTunnelDump.class)); }
VhostUserCustomizer implements InitializingReaderCustomizer<VhostUser, VhostUserBuilder>, InterfaceDataTranslator, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUserBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); final SwInterfaceDetails ifcDetails = dumpManager.getInterfaceDetail(id, ctx, key.getName()); if (!isInterfaceOfType( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190527.VhostUser.class, ifcDetails)) { return; } LOG.debug("Reading attributes for vhpost user interface: {}", key.getName()); final SwInterfaceVhostUserDetailsReplyDump dump = vhostDumpManager.getDump(id, ctx.getModificationCache()) .orElse(new SwInterfaceVhostUserDetailsReplyDump()); final SwInterfaceVhostUserDetails swInterfaceVhostUserDetails = dump.swInterfaceVhostUserDetails.stream() .filter(detail -> detail.swIfIndex == index) .findFirst() .orElseThrow(() -> new IllegalArgumentException( format("Vhost user for interface %s not found", key.getName()))); LOG.trace("Vhost user interface: {} attributes returned from VPP: {}", key.getName(), swInterfaceVhostUserDetails); builder.setRole(swInterfaceVhostUserDetails.isServer == 1 ? VhostUserRole.Server : VhostUserRole.Client); builder.setFeatures(BigInteger.valueOf(swInterfaceVhostUserDetails.features)); builder.setNumMemoryRegions((long) swInterfaceVhostUserDetails.numRegions); builder.setSocket(toString(swInterfaceVhostUserDetails.sockFilename)); builder.setVirtioNetHdrSize((long) swInterfaceVhostUserDetails.virtioNetHdrSz); builder.setConnectError(Integer.toString(swInterfaceVhostUserDetails.sockErrno)); if (ifcDetails.tag[0] != 0) { builder.setTag(toString(ifcDetails.tag)); } LOG.debug("Vhost user interface: {}, id: {} attributes read as: {}", key.getName(), index, builder); } VhostUserCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull VhostUser readValue); @Nonnull @Override VhostUserBuilder getBuilder(@Nonnull InstanceIdentifier<VhostUser> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUserBuilder builder, @Nonnull final ReadContext ctx); @Override Initialized<VhostUser> init(@Nonnull final InstanceIdentifier<VhostUser> id, @Nonnull final VhostUser readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws ReadFailedException { final VhostUserBuilder builder = mock(VhostUserBuilder.class); when(api.swInterfaceVhostUserDump(any())).thenReturn(future(vhostDump())); getCustomizer().readCurrentAttributes(IID, builder, ctx); verifyVhostBuilder(builder); } @Test(expected = ReadFailedException.class) public void testReadFailed() throws ReadFailedException { when(api.swInterfaceVhostUserDump(any())).thenReturn(failedFuture()); getCustomizer().readCurrentAttributes(IID, mock(VhostUserBuilder.class), ctx); }
L2Customizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<L2, L2Builder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2Builder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for L2: {}", id); final InterfaceKey key = id.firstKeyOf(Interface.class); final String ifaceName = key.getName(); builder.setInterconnection(icReadUtils.readInterconnection(id, ifaceName, ctx)); } L2Customizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext, @Nonnull final NamingContext bridgeDomainContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final L2 readValue); @Nonnull @Override L2Builder getBuilder(@Nonnull final InstanceIdentifier<L2> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2Builder builder, @Nonnull final ReadContext ctx); @Override Initialized<L2> init(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadBvi() throws Exception { final int ifId = 1; final int bdId = 1; final String bdName = "bd001"; final String ifName = "eth0.sub0"; defineMapping(mappingContext, ifName, ifId, IFC_CTX_NAME); defineMapping(mappingContext, bdName, bdId, BD_CTX_NAME); final SwInterfaceDetails ifaceDetails = new SwInterfaceDetails(); ifaceDetails.subId = ifId; whenBridgeDomainDumpThenReturn(Collections.singletonList(generateBdDetails(ifId, ifId, bdId))); L2Builder builder = mock(L2Builder.class); getCustomizer().readCurrentAttributes(getL2Id(ifName), builder, ctx); verify(builder).setInterconnection(generateInterconnection(bdName, true)); } @Test public void testReadNoBvi() throws Exception { final Map<Integer, SwInterfaceDetails> cachedInterfaceDump = new HashMap<>(); final int ifId = 1; final int bdId = 1; final String bdName = "bd001"; final String ifName = "eth0.sub0"; defineMapping(mappingContext, ifName, ifId, IFC_CTX_NAME); defineMapping(mappingContext, bdName, bdId, BD_CTX_NAME); final SwInterfaceDetails ifaceDetails = new SwInterfaceDetails(); ifaceDetails.subId = ifId; cachedInterfaceDump.put(ifId, ifaceDetails); whenBridgeDomainDumpThenReturn(Collections .singletonList(generateBdDetails(ifId, 99 , bdId))); L2Builder builder = mock(L2Builder.class); getCustomizer().readCurrentAttributes(getL2Id(ifName), builder, ctx); verify(builder).setInterconnection(generateInterconnection(bdName, null)); }
SubInterfaceCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<SubInterface, SubInterfaceKey, SubInterfaceBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterfaceBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final String subInterfaceName = getSubInterfaceName(id); LOG.debug("Reading attributes for sub interface: {}", subInterfaceName); final SwInterfaceDetails iface = dumpManager.getInterfaceDetail(id, ctx, subInterfaceName); LOG.debug("VPP sub-interface details: {}", iface); checkState(isSubInterface(iface), "Interface returned by the VPP is not a sub-interface"); builder.setIdentifier((long) iface.subId); builder.withKey(new SubInterfaceKey(builder.getIdentifier())); builder.setTags(readTags(iface)); builder.setMatch(readMatch(iface)); builder.setAdminStatus(1 == iface.adminUpDown ? SubInterfaceStatus.Up : SubInterfaceStatus.Down); builder.setOperStatus(1 == iface.linkUpDown ? SubInterfaceStatus.Up : SubInterfaceStatus.Down); builder.setIfIndex(vppIfIndexToYang(iface.swIfIndex)); if (iface.l2AddressLength == 6) { builder.setPhysAddress(new PhysAddress(vppPhysAddrToYang(iface.l2Address))); } if (0 != iface.linkSpeed) { builder.setSpeed(vppInterfaceSpeedToYang(iface.linkSpeed)); } } SubInterfaceCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Nonnull @Override List<SubInterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<SubInterface> readData); @Nonnull @Override SubInterfaceBuilder getBuilder(@Nonnull final InstanceIdentifier<SubInterface> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterfaceBuilder builder, @Nonnull final ReadContext ctx); @Override Initialized<SubInterface> init( @Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface readValue, @Nonnull final ReadContext ctx); static InstanceIdentifier<SubInterface> getCfgId(final InstanceIdentifier<SubInterface> id); }
@Test public void testRead() throws ReadFailedException { final SwInterfaceDetails ifaceDetails = new SwInterfaceDetails(); ifaceDetails.subId = VLAN_IF_ID; ifaceDetails.interfaceName = VLAN_IF_NAME.getBytes(); ifaceDetails.swIfIndex = 2; ifaceDetails.supSwIfIndex = SUPER_IF_INDEX; defineMapping(mappingContext, SUPER_IF_NAME, SUPER_IF_INDEX, IFC_CTX_NAME); defineMapping(mappingContext, VLAN_IF_NAME, VLAN_IF_INDEX, IFC_CTX_NAME); ifaceDetails.subNumberOfTags = 2; ifaceDetails.subOuterVlanIdAny = 1; ifaceDetails.subInnerVlanIdAny = 1; ifaceDetails.subExactMatch = 1; final SubInterfaceBuilder builder = mock(SubInterfaceBuilder.class); final InstanceIdentifier<SubInterface> subInterfaceId = getSubInterfaceId(SUPER_IF_NAME, VLAN_IF_ID); when(dumpCacheManager.getInterfaceDetail(subInterfaceId, ctx, VLAN_IF_NAME)).thenReturn(ifaceDetails); getCustomizer().readCurrentAttributes(subInterfaceId, builder, ctx); verify(builder).setIdentifier((long) VLAN_IF_ID); ArgumentCaptor<Tags> tagCaptor = ArgumentCaptor.forClass(Tags.class); verify(builder).setTags(tagCaptor.capture()); assertEquals(ifaceDetails.subNumberOfTags, tagCaptor.getValue().getTag().size()); ArgumentCaptor<Match> matchCaptor = ArgumentCaptor.forClass(Match.class); verify(builder).setMatch(matchCaptor.capture()); final VlanTagged matchType = (VlanTagged) matchCaptor.getValue().getMatchType(); assertTrue(matchType.getVlanTagged().isMatchExactTags()); }
SubInterfaceCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<SubInterface, SubInterfaceKey, SubInterfaceBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Nonnull @Override public List<SubInterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final ReadContext context) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final String ifaceName = key.getName(); final int ifaceId = interfaceContext.getIndex(ifaceName, context.getMappingContext()); final List<SubInterfaceKey> interfacesKeys = dumpManager.getInterfaces(id,context) .filter(Objects::nonNull) .filter(elt -> isSubInterface(elt) && elt.supSwIfIndex == ifaceId) .map(details -> new SubInterfaceKey(new Long(details.subId))) .collect(Collectors.toList()); LOG.debug("Sub-interfaces of {} found in VPP: {}", ifaceName, interfacesKeys); return interfacesKeys; } SubInterfaceCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Nonnull @Override List<SubInterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<SubInterface> readData); @Nonnull @Override SubInterfaceBuilder getBuilder(@Nonnull final InstanceIdentifier<SubInterface> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterfaceBuilder builder, @Nonnull final ReadContext ctx); @Override Initialized<SubInterface> init( @Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface readValue, @Nonnull final ReadContext ctx); static InstanceIdentifier<SubInterface> getCfgId(final InstanceIdentifier<SubInterface> id); }
@Test public void testGetAllIds() throws Exception { final SwInterfaceDetails iface = new SwInterfaceDetails(); iface.interfaceName = VLAN_IF_NAME.getBytes(); iface.swIfIndex = VLAN_IF_INDEX; iface.subId = VLAN_IF_ID; iface.supSwIfIndex = SUPER_IF_INDEX; final InstanceIdentifier<SubInterface> subInterfaceId = getSubInterfaceId(SUPER_IF_NAME, VLAN_IF_ID); when(dumpCacheManager.getInterfaces(subInterfaceId, ctx)).thenReturn(Stream.of(iface)); final List<SubInterfaceKey> allIds = getCustomizer().getAllIds(subInterfaceId, ctx); assertEquals(1, allIds.size()); }
InterfaceCacheDumpManagerImpl implements InterfaceCacheDumpManager, InterfaceDataTranslator { @Override @Nonnull public synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading all interfaces[{}]", identifier); return initMapAndGet(identifier, ctx).entrySet().stream().map(Map.Entry::getValue); } InterfaceCacheDumpManagerImpl(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext namingContext); @Override @Nonnull synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx); @Override @Nullable synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx, @Nonnull final String interfaceName); }
@Test public void getInterfaces() throws Exception { assertFalse(cache.containsKey(BY_NAME_INDEX_KEY)); final List<SwInterfaceDetails> interfaces = manager.getInterfaces(identifier, ctx).collect(Collectors.toList()); assertEquals(3, interfaces.size()); assertTrue(interfaces.contains(detailZero())); assertTrue(interfaces.contains(detailOne())); assertTrue(interfaces.contains(detailTwo())); verify(jvpp, times(1)).swInterfaceDump(fullRequest()); assertTrue(cache.containsKey(BY_NAME_INDEX_KEY)); final List<SwInterfaceDetails> cachedInterfaces = manager.getInterfaces(identifier, ctx).collect(Collectors.toList()); assertEquals(3, cachedInterfaces.size()); assertTrue(cachedInterfaces.contains(detailZero())); assertTrue(cachedInterfaces.contains(detailOne())); assertTrue(cachedInterfaces.contains(detailTwo())); verifyNoMoreInteractions(jvpp); }
InterfaceCacheDumpManagerImpl implements InterfaceCacheDumpManager, InterfaceDataTranslator { @Override @Nullable public synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx, @Nonnull final String interfaceName) throws ReadFailedException { final Map<String, SwInterfaceDetails> interfaceIndex = getMap(ctx); if (interfaceIndex != null) { return interfaceIndex.get(interfaceName); } else { return dumpSpecificDetail(identifier, ctx, interfaceName); } } InterfaceCacheDumpManagerImpl(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext namingContext); @Override @Nonnull synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx); @Override @Nullable synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx, @Nonnull final String interfaceName); }
@Test public void getInterfaceDetailFromCache() throws Exception { final HashMap<Object, Object> cachedMap = new HashMap<>(); final SwInterfaceDetails detailZero = detailZero(); cachedMap.put(IFACE_0, detailZero); cache.put(BY_NAME_INDEX_KEY, cachedMap); when(jvpp.swInterfaceDump(specificRequest(IFACE_0))).thenReturn(future(specificReplyZero())); final SwInterfaceDetails interfaceDetail = manager.getInterfaceDetail(identifier, ctx, IFACE_0); assertEquals(detailZero, interfaceDetail); verifyZeroInteractions(jvpp); } @Test public void getInterfaceDetailNotInFullDump() throws Exception { assertFalse(cache.containsKey(BY_NAME_INDEX_KEY)); final SwInterfaceDetails specificDetail = manager.getInterfaceDetail(identifierThree, ctx, IFACE_3); assertEquals(detailThree(), specificDetail); verify(jvpp, times(1)).swInterfaceDump(specificRequest(3)); }
TapV2Customizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<TapV2, TapV2Builder>, InterfaceDataTranslator, JvppReplyConsumer, MacTranslator, Ipv4Translator, Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2Builder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final InterfaceKey key = id.firstKeyOf(Interface.class); final int index = interfaceContext.getIndex(key.getName(), ctx.getMappingContext()); if (!isInterfaceOfType(dumpManager, id, ctx, org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.rev190527.TapV2.class)) { return; } LOG.debug("Reading attributes for tapV2 interface: {}", key.getName()); final SwInterfaceTapV2DetailsReplyDump reply = tapV2DumpManager.getDump(id, ctx.getModificationCache()) .orElse(new SwInterfaceTapV2DetailsReplyDump()); final Optional<SwInterfaceTapV2Details> detail = reply.swInterfaceTapV2Details.stream() .filter(d -> d.swIfIndex == index) .findAny(); checkState(detail.isPresent(), "TapV2 interface for index %s not found", index); final SwInterfaceTapV2Details swInterfaceTapV2Details = detail.get(); LOG.trace("TapV2 interface: {} attributes returned from VPP: {}", key.getName(), swInterfaceTapV2Details); if (swInterfaceTapV2Details.devName != null && swInterfaceTapV2Details.devName[0] != 0) { builder.setDeviceName(toString(swInterfaceTapV2Details.devName)); } else { builder.setDeviceName(null); } if (swInterfaceTapV2Details.hostBridge != null && swInterfaceTapV2Details.hostBridge[0] != 0) { builder.setHostBridge(toString(swInterfaceTapV2Details.hostBridge)); } else { builder.setHostBridge(null); } if (swInterfaceTapV2Details.hostMacAddr != null && !ByteDataTranslator.INSTANCE.isArrayZeroed(swInterfaceTapV2Details.hostMacAddr)) { builder.setHostMac(toPhysAddress(swInterfaceTapV2Details.hostMacAddr)); } else { builder.setHostMac(null); } if (swInterfaceTapV2Details.hostIfName != null && swInterfaceTapV2Details.hostIfName[0] != 0) { builder.setHostInterfaceName(toString(swInterfaceTapV2Details.hostIfName)); } else { builder.setHostInterfaceName(null); } if (swInterfaceTapV2Details.hostIp4Addr != null && swInterfaceTapV2Details.hostIp4PrefixLen != 0) { builder.setHostIpv4Address( toIpv4Prefix(swInterfaceTapV2Details.hostIp4Addr, swInterfaceTapV2Details.hostIp4PrefixLen)); } else { builder.setHostIpv4Address(null); } if (swInterfaceTapV2Details.hostIp6Addr != null && swInterfaceTapV2Details.hostIp6PrefixLen != 0) { builder.setHostIpv6Address( toIpv6Prefix(swInterfaceTapV2Details.hostIp6Addr, Byte.toUnsignedInt(swInterfaceTapV2Details.hostIp6PrefixLen))); } else { builder.setHostIpv6Address(null); } if (swInterfaceTapV2Details.hostNamespace != null && swInterfaceTapV2Details.hostNamespace[0] != 0) { builder.setHostNamespace(toString(swInterfaceTapV2Details.hostNamespace)); } else { builder.setHostNamespace(null); } builder.setRxRingSize(Short.toUnsignedInt(swInterfaceTapV2Details.rxRingSz)); builder.setTxRingSize(Short.toUnsignedInt(swInterfaceTapV2Details.txRingSz)); final SwInterfaceDetails ifcDetails = dumpManager.getInterfaceDetail(id, ctx, key.getName()); if (ifcDetails.tag[0] != 0) { builder.setTag(toString(ifcDetails.tag)); } LOG.debug("TapV2 interface: {}, id: {} attributes read as: {}", key.getName(), index, builder); } TapV2Customizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Override void merge(@Nonnull Builder<? extends DataObject> parentBuilder, @Nonnull TapV2 readValue); @Nonnull @Override TapV2Builder getBuilder(@Nonnull InstanceIdentifier<TapV2> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2Builder builder, @Nonnull final ReadContext ctx); @Override Initialized<TapV2> init(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws ReadFailedException { final TapV2Builder builder = mock(TapV2Builder.class); when(api.swInterfaceTapV2Dump(any())).thenReturn(future(tapDump())); getCustomizer().readCurrentAttributes(IID, builder, ctx); verify(builder).setHostInterfaceName(IF_NAME); verify(builder).setDeviceName(DEVICE_NAME); verify(builder).setHostBridge(HOST_BRIDGE); verify(builder) .setHostIpv4Address(new Ipv4Prefix(String.format("%s/%d", HOST_IPV4_PREFIX, HOST_IPV4_PREFIX_LEN))); verify(builder) .setHostIpv6Address(new Ipv6Prefix(String.format("%s/%d", HOST_IPV6_PREFIX, HOST_IPV6_PREFIX_LEN_EXP))); verify(builder).setTxRingSize(RX_TX_RING_SIZE); verify(builder).setRxRingSize(RX_TX_RING_SIZE); verify(builder).setHostNamespace(HOST_NAMESPACE); verify(builder).setHostMac(new PhysAddress(HOST_MAC)); } @Test(expected = ReadFailedException.class) public void testReadFailed() throws ReadFailedException { when(api.swInterfaceTapV2Dump(any())).thenReturn(failedFuture()); getCustomizer().readCurrentAttributes(IID, mock(TapV2Builder.class), ctx); }
InterfaceCustomizer implements InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<Interface> id, @Nonnull InterfaceBuilder builder, @Nonnull ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for interface: {}", id); final String ifaceName = id.firstKeyOf(id.getTargetType()).getName(); final int index = interfaceNamingContext.getIndex(ifaceName, ctx.getMappingContext()); if (interfaceDisableContext.isInterfaceDisabled(index, ctx.getMappingContext())) { LOG.debug("Skipping disabled interface: {}", id); return; } final SwInterfaceDetails iface = dumpManager.getInterfaceDetail(id, ctx, ifaceName); LOG.debug("Interface details for interface: {}, details: {}", ifaceName, iface); if (!isRegularInterface(iface)) { LOG.debug("Interface: {} is a sub-interface. Ignoring read request.", ifaceName); return; } builder.setName(ifaceName); builder.setType(getInterfaceType(new String(iface.interfaceName).intern())); builder.setIfIndex(vppIfIndexToYang(iface.swIfIndex)); builder.setAdminStatus(1 == iface.adminUpDown ? AdminStatus.Up : AdminStatus.Down); builder.setOperStatus(1 == iface.linkUpDown ? OperStatus.Up : OperStatus.Down); if (0 != iface.linkSpeed) { builder.setSpeed(vppInterfaceSpeedToYang(iface.linkSpeed)); } if (iface.l2AddressLength == 6) { builder.setPhysAddress(new PhysAddress(vppPhysAddrToYang(iface.l2Address))); } LOG.trace("Base attributes read for interface: {} as: {}", ifaceName, builder); } InterfaceCustomizer(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Nonnull @Override InterfaceBuilder getBuilder(@Nonnull InstanceIdentifier<Interface> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Interface> id, @Nonnull InterfaceBuilder builder, @Nonnull ReadContext ctx); @Nonnull @Override List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final org.opendaylight.yangtools.concepts.Builder<? extends DataObject> builder, @Nonnull final List<Interface> readData); @Override Initialized<Interface> init( @Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface readValue, @Nonnull final ReadContext ctx); static InstanceIdentifier<Interface> getCfgId(final InstanceIdentifier<Interface> id); }
@Test public void testReadCurrentAttributes() throws Exception { final InstanceIdentifier<Interface> id = InstanceIdentifier.create(Interfaces.class) .child(Interface.class, new InterfaceKey(IFACE0_NAME)); final InterfaceBuilder builder = getCustomizer().getBuilder(id); final SwInterfaceDetails iface = new SwInterfaceDetails(); iface.interfaceName = IFACE0_NAME.getBytes(); iface.swIfIndex = 0; iface.linkSpeed = 1; iface.l2AddressLength = 6; iface.l2Address = new byte[iface.l2AddressLength]; when(dumpCacheManager.getInterfaceDetail(id, ctx, IFACE0_NAME)).thenReturn(iface); getCustomizer().readCurrentAttributes(id, builder, ctx); final SwInterfaceDump request = new SwInterfaceDump(); request.swIfIndex = new InterfaceIndex(); request.swIfIndex.interfaceindex =~0; request.nameFilter = IFACE0_NAME.getBytes(); request.nameFilterValid = 1; assertIfacesAreEqual(builder.build(), iface); verify(dumpCacheManager, times(1)).getInterfaceDetail(id, ctx, IFACE0_NAME); } @Test public void testReadSubInterface() throws Exception { final InstanceIdentifier<Interface> id = InstanceIdentifier.create(Interfaces.class) .child(Interface.class, new InterfaceKey(SUB_IFACE_NAME)); final InterfaceBuilder builder = mock(InterfaceBuilder.class); final SwInterfaceDetails iface = new SwInterfaceDetails(); iface.interfaceName = SUB_IFACE_NAME.getBytes(); iface.swIfIndex = 2; iface.supSwIfIndex = 1; iface.subId = 1; when(dumpCacheManager.getInterfaceDetail(id, ctx, SUB_IFACE_NAME)).thenReturn(iface); getCustomizer().readCurrentAttributes(id, builder, ctx); final SwInterfaceDump request = new SwInterfaceDump(); request.swIfIndex = new InterfaceIndex(); request.swIfIndex.interfaceindex =~0; request.nameFilter = SUB_IFACE_NAME.getBytes(); request.nameFilterValid = 1; verifyZeroInteractions(builder); verify(dumpCacheManager, times(1)).getInterfaceDetail(id, ctx, SUB_IFACE_NAME); }
InterfaceCustomizer implements InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Nonnull @Override public List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final ReadContext context) throws ReadFailedException { final List<InterfaceKey> interfacesKeys; LOG.trace("Dumping all interfaces to get all IDs"); final MappingContext mappingCtx = context.getMappingContext(); final Set<Integer> interfacesIdxs = dumpManager.getInterfaces(id, context) .filter(elt -> elt != null) .filter(elt -> !interfaceDisableContext .isInterfaceDisabled(elt.swIfIndex, mappingCtx)) .filter(InterfaceDataTranslator.INSTANCE::isRegularInterface) .map(elt -> elt.swIfIndex) .collect(Collectors.toSet()); interfaceDisableContext.getDisabledInterfaces(mappingCtx).stream() .filter(interfacesIdxs::contains) .forEach(idx -> interfaceDisableContext.removeDisabledInterface(idx, mappingCtx)); interfacesKeys = interfacesIdxs.stream() .map(index -> new InterfaceKey(interfaceNamingContext.getName(index, context.getMappingContext()))) .collect(Collectors.toList()); LOG.debug("Interfaces found in VPP: {}", interfacesKeys); return interfacesKeys; } InterfaceCustomizer(@Nonnull final NamingContext interfaceNamingContext, @Nonnull final DisabledInterfacesManager interfaceDisableContext, @Nonnull final InterfaceCacheDumpManager dumpManager); @Nonnull @Override InterfaceBuilder getBuilder(@Nonnull InstanceIdentifier<Interface> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Interface> id, @Nonnull InterfaceBuilder builder, @Nonnull ReadContext ctx); @Nonnull @Override List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final org.opendaylight.yangtools.concepts.Builder<? extends DataObject> builder, @Nonnull final List<Interface> readData); @Override Initialized<Interface> init( @Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface readValue, @Nonnull final ReadContext ctx); static InstanceIdentifier<Interface> getCfgId(final InstanceIdentifier<Interface> id); }
@Test public void testGetAllIds() throws Exception { final InstanceIdentifier<Interface> id = InstanceIdentifier.create(Interfaces.class) .child(Interface.class); final SwInterfaceDetails swIf0 = new SwInterfaceDetails(); swIf0.swIfIndex = 0; swIf0.supSwIfIndex = 0; swIf0.interfaceName = IFACE0_NAME.getBytes(); final SwInterfaceDetails swIf1 = new SwInterfaceDetails(); swIf1.swIfIndex = 1; swIf1.supSwIfIndex = 1; swIf1.interfaceName = IFACE1_NAME.getBytes(); final SwInterfaceDetails swSubIf1 = new SwInterfaceDetails(); swSubIf1.swIfIndex = 2; swSubIf1.subId = 1; swSubIf1.supSwIfIndex = 1; swSubIf1.interfaceName = SUB_IFACE_NAME.getBytes(); when(dumpCacheManager.getInterfaces(id, ctx)).thenReturn(Stream.of(swIf0, swIf1, swSubIf1)); final List<InterfaceKey> expectedIds = Arrays.asList(new InterfaceKey(IFACE0_NAME), new InterfaceKey( IFACE1_NAME)); final List<InterfaceKey> actualIds = getCustomizer().getAllIds(id, ctx); final SwInterfaceDump request = new SwInterfaceDump(); request.swIfIndex = new InterfaceIndex(); request.swIfIndex.interfaceindex = ~0; request.nameFilter = "".getBytes(); request.nameFilterValid = 0; assertEquals(expectedIds, actualIds); verify(dumpCacheManager, times(1)).getInterfaces(id, ctx); } @Test public void testGetAllIdsWithDisabled() throws Exception { final InstanceIdentifier<Interface> id = InstanceIdentifier.create(Interfaces.class) .child(Interface.class); doReturn(true).when(interfaceDisableContext).isInterfaceDisabled(1, mappingContext); final SwInterfaceDetails swIf0 = new SwInterfaceDetails(); swIf0.swIfIndex = 0; swIf0.interfaceName = IFACE0_NAME.getBytes(); final SwInterfaceDetails swIf1 = new SwInterfaceDetails(); swIf1.swIfIndex = 1; swIf1.interfaceName = IFACE1_NAME.getBytes(); when(dumpCacheManager.getInterfaces(id, ctx)).thenReturn(Stream.of(swIf0, swIf1)); final List<InterfaceKey> expectedIds = Arrays.asList(new InterfaceKey(IFACE0_NAME)); final List<InterfaceKey> actualIds = getCustomizer().getAllIds(id, ctx); assertEquals(expectedIds, actualIds); verify(dumpCacheManager, times(1)).getInterfaces(id, ctx); }
InterfaceRoutingCustomizer extends RoutingCustomizer implements InitializingReaderCustomizer<Routing, RoutingBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final RoutingBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for Routing: {}", id); final String ifName = id.firstKeyOf(Interface.class).getName(); readInterfaceRouting(id, builder::setIpv4VrfId, builder::setIpv6VrfId, ctx, ifName); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext interfaceContext); @Nonnull @Override RoutingBuilder getBuilder(@Nonnull final InstanceIdentifier<Routing> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final RoutingBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final Routing readValue); @Nonnull @Override Initialized<Routing> init(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws Exception { final RoutingBuilder builder = mock(RoutingBuilder.class); when(api.swInterfaceGetTable(any())).thenReturn(future(tableReply(IP4_VRF_ID))).thenReturn(future(tableReply(IP6_VRF_ID))); getCustomizer().readCurrentAttributes(getRoutingId(IF_NAME), builder, ctx); verify(builder).setIpv4VrfId(new VniReference(IP4_VRF_ID)); verify(builder).setIpv6VrfId(new VniReference(IP6_VRF_ID)); } @Test public void testReadRoutingNotDefined() throws Exception { final RoutingBuilder builder = mock(RoutingBuilder.class); final Long vrfId = 0L; when(api.swInterfaceGetTable(any())).thenReturn(future(tableReply(vrfId))); getCustomizer().readCurrentAttributes(getRoutingId(IF_NAME), builder, ctx); verifyZeroInteractions(builder); }
ArpTerminationTableEntryCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<ArpTerminationTableEntry, ArpTerminationTableEntryKey>, ByteDataTranslator, AddressTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Creating ARP termination table entry: {} {}", id, dataAfter); bdIpMacAddDel(id, dataAfter, writeContext, true); LOG.debug("L2 ARP termination table entry created successfully: {} {}", id, dataAfter); } ArpTerminationTableEntryCustomizer(@Nonnull final FutureJVppCore futureJvpp, @Nonnull final NamingContext bdContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testCreate() throws Exception { whenBdIpMacAddDelThenSuccess(); customizer.writeCurrentAttributes(id, entry, writeContext); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ipAddressRaw, physAddressRaw, (byte) 1)); } @Test public void testCreateIpv6() throws Exception { whenBdIpMacAddDelThenSuccess(); customizer.writeCurrentAttributes(id, ip6entry, writeContext); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ip6AddressRaw, physAddressRaw, (byte) 1)); } @Test public void testCreateFailed() throws Exception { whenBdIpMacAddDelThenFailure(); try { customizer.writeCurrentAttributes(id, entry, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ipAddressRaw, physAddressRaw, (byte) 1)); return; } fail("WriteFailedException.CreateFailedException was expected"); }
ArpTerminationTableEntryCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<ArpTerminationTableEntry, ArpTerminationTableEntryKey>, ByteDataTranslator, AddressTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Deleting ARP termination table entry entry: {} {}", id, dataBefore); bdIpMacAddDel(id, dataBefore, writeContext, false); LOG.debug("ARP termination table entry deleted successfully: {} {}", id, dataBefore); } ArpTerminationTableEntryCustomizer(@Nonnull final FutureJVppCore futureJvpp, @Nonnull final NamingContext bdContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ArpTerminationTableEntry> id, @Nonnull final ArpTerminationTableEntry dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws Exception { whenBdIpMacAddDelThenSuccess(); customizer.deleteCurrentAttributes(id, entry, writeContext); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ipAddressRaw, physAddressRaw, (byte) 0)); } @Test public void testDeleteIpv6() throws Exception { whenBdIpMacAddDelThenSuccess(); customizer.deleteCurrentAttributes(id, ip6entry, writeContext); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ip6AddressRaw, physAddressRaw, (byte) 0)); } @Test public void testDeleteFailed() throws Exception { whenBdIpMacAddDelThenFailure(); try { customizer.deleteCurrentAttributes(id, entry, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyBdIpMacAddDelWasInvoked(generateBdIpMacAddDelRequest(ipAddressRaw, physAddressRaw, (byte) 0)); return; } fail("WriteFailedException.DeleteFailedException was expected"); }
Ipv4RouteCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Route, RouteKey>, JvppReplyConsumer, RouteMapper { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route routeBefore, @Nonnull final Route routeAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(instanceIdentifier, routeBefore, routeAfter, new UnsupportedOperationException("Operation not supported")); } Ipv4RouteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext, @Nonnull final NamingContext routesContext, @Nonnull final NamingContext routingProtocolContext, @Nonnull final MultiNamingContext routesHopsContext, @Nonnull final VppClassifierContextManager classifierContextManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route routeBefore, @Nonnull final Route routeAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate( @InjectTestData(resourcePath = "/ipv4/specialhop/specialHopRouteBlackhole.json", id = STATIC_ROUTE_PATH) StaticRoutes route) { try { customizer.updateCurrentAttributes(ROUTE_IID, new RouteBuilder().build(), getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof UnsupportedOperationException); verifyNotInvoked(api); return; } fail("Test should have thrown exception"); }
L2FibEntryCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<L2FibEntry, L2FibEntryKey>, ByteDataTranslator, MacTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Creating L2 FIB entry: {} {}", id, dataAfter); l2FibAddDel(id, dataAfter, writeContext, true); LOG.debug("L2 FIB entry created successfully: {} {}", id, dataAfter); } L2FibEntryCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext bdContext, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry dataBefore, @Nonnull final WriteContext writeContext); static final int NO_INTERFACE_REF; }
@Test public void testCreateFilter() throws Exception { final byte[] address_vpp = new byte[]{1, 2, 3, 4, 5, 6}; final PhysAddress address = new PhysAddress("01:02:03:04:05:06"); final L2FibEntry entry = generateL2FibFilterEntry(address); final InstanceIdentifier<L2FibEntry> id = getL2FibEntryId(address); whenL2FibAddDelThenSuccess(); customizer.writeCurrentAttributes(id, entry, writeContext); verifyL2FibAddDelWasInvoked(generateL2FibAddDelFilterRequest(address_vpp, (byte) 1, NO_INTERFACE)); } @Test public void testCreateForward() throws Exception { final byte[] address_vpp = new byte[]{1, 2, 3, 4, 5, 6}; final PhysAddress address = new PhysAddress("01:02:03:04:05:06"); final L2FibEntry entry = generateL2FibForwardEntry(address); final InstanceIdentifier<L2FibEntry> id = getL2FibEntryId(address); whenL2FibAddDelThenSuccess(); customizer.writeCurrentAttributes(id, entry, writeContext); verifyL2FibAddDelWasInvoked(generateL2FibAddDelForwardRequest(address_vpp, (byte) 1, IFACE_ID)); } @Test public void testCreateFilterFailed() throws Exception { final byte[] address_vpp = new byte[]{0x11, 0x22 ,0x33, 0x44 ,0x55, 0x66}; final PhysAddress address = new PhysAddress("11:22:33:44:55:66"); final L2FibEntry entry = generateL2FibFilterEntry(address); final InstanceIdentifier<L2FibEntry> id = getL2FibEntryId(address); whenL2FibAddDelThenFailure(); try { customizer.writeCurrentAttributes(id, entry, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyL2FibAddDelWasInvoked(generateL2FibAddDelFilterRequest(address_vpp, (byte) 1, NO_INTERFACE)); return; } fail("WriteFailedException.CreateFailedException was expected"); } @Test public void testCreateForwardFailed() throws Exception { final byte[] address_vpp = new byte[]{0x11, 0x22 ,0x33, 0x44 ,0x55, 0x66}; final PhysAddress address = new PhysAddress("11:22:33:44:55:66"); final L2FibEntry entry = generateL2FibForwardEntry(address); final InstanceIdentifier<L2FibEntry> id = getL2FibEntryId(address); whenL2FibAddDelThenFailure(); try { customizer.writeCurrentAttributes(id, entry, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyL2FibAddDelWasInvoked(generateL2FibAddDelForwardRequest(address_vpp, (byte) 1, IFACE_ID)); return; } fail("WriteFailedException.CreateFailedException was expected"); }