src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
LispStateCheckServiceImpl implements LispStateCheckService, JvppReplyConsumer, ByteDataTranslator { @Override public void checkLispEnabledAfter(@Nonnull final WriteContext ctx) { checkState(ctx.readAfter(InstanceIdentifier.create(Lisp.class)) .orElse(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled"); } @Inject LispStateCheckServiceImpl(@Nonnull final FutureJVppCore vppApi); @Override void checkLispEnabledBefore(@Nonnull final WriteContext ctx); @Override void checkLispEnabledAfter(@Nonnull final WriteContext ctx); @Override boolean lispEnabled(@Nonnull final ReadContext ctx); } | @Test(expected = IllegalStateException.class) public void testCheckLispEnabledAfterNoConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.empty()); impl.checkLispEnabledAfter(writeContext); }
@Test(expected = IllegalStateException.class) public void testCheckLispEnabledAfterDisabledConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(false).build())); impl.checkLispEnabledAfter(writeContext); }
@Test public void testCheckLispEnabledAfterEnabledConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(true).build())); impl.checkLispEnabledAfter(writeContext); } |
LispStateCheckServiceImpl implements LispStateCheckService, JvppReplyConsumer, ByteDataTranslator { @Override public boolean lispEnabled(@Nonnull final ReadContext ctx) { try { return byteToBoolean(dumpManager.getDump(IDENTIFIER, ctx.getModificationCache()) .orElse(DEFAULT_REPLY).featureStatus); } catch (ReadFailedException e) { throw new IllegalStateException("Unable to read Lisp Feature status", e); } } @Inject LispStateCheckServiceImpl(@Nonnull final FutureJVppCore vppApi); @Override void checkLispEnabledBefore(@Nonnull final WriteContext ctx); @Override void checkLispEnabledAfter(@Nonnull final WriteContext ctx); @Override boolean lispEnabled(@Nonnull final ReadContext ctx); } | @Test public void testLispEnabledDisabledDump() throws Exception { when(vppApi.showOneStatus(any())).thenReturn(future(new ShowOneStatusReply())); assertFalse(impl.lispEnabled(readContext)); }
@Test public void testLispEnabledEnabledDump() throws Exception { final ShowOneStatusReply reply = new ShowOneStatusReply(); reply.featureStatus = 1; when(vppApi.showOneStatus(any())).thenReturn(future(reply)); assertTrue(impl.lispEnabled(readContext)); } |
PitrCfgCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<PitrCfg, PitrCfgBuilder>, ByteDataTranslator, JvppReplyConsumer,
LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<PitrCfg> id, PitrCfgBuilder builder, ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } LOG.debug("Reading status for Lisp Pitr node {}", id); ShowOnePitrReply reply; try { reply = getPitrStatus(); } catch (TimeoutException | VppBaseCallException e) { throw new ReadFailedException(id, e); } builder.setLocatorSet(toString(reply.locatorSetName)); LOG.debug("Reading status for Lisp Pitr node {} successfull", id); } PitrCfgCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override PitrCfgBuilder getBuilder(InstanceIdentifier<PitrCfg> id); @Override void readCurrentAttributes(InstanceIdentifier<PitrCfg> id, PitrCfgBuilder builder, ReadContext ctx); @Override void merge(Builder<? extends DataObject> parentBuilder, PitrCfg readValue); ShowOnePitrReply getPitrStatus(); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PitrCfg> instanceIdentifier, @Nonnull PitrCfg pitrCfg, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributes() throws Exception { PitrCfgBuilder builder = new PitrCfgBuilder(); getCustomizer().readCurrentAttributes(emptyId, builder, ctx); final PitrCfg cfg = builder.build(); assertNotNull(cfg); assertEquals("loc-set", cfg.getLocatorSet()); } |
LocatorSetCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<LocatorSet, LocatorSetKey, LocatorSetBuilder>, ByteDataTranslator,
LocatorSetReader, LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } LOG.debug("Reading attributes for Locator Set {}", id); final Optional<OneLocatorSetDetailsReplyDump> dumpOptional = dumpManager.getDump(id, ctx.getModificationCache()); if (!dumpOptional.isPresent() || dumpOptional.get().oneLocatorSetDetails.isEmpty()) { return; } String keyName = id.firstKeyOf(LocatorSet.class).getName(); OneLocatorSetDetailsReplyDump dump = dumpOptional.get(); java.util.Optional<OneLocatorSetDetails> details = dump.oneLocatorSetDetails.stream() .filter(n -> keyName.equals(toString(n.lsName))) .findFirst(); if (details.isPresent()) { final String name = toString(details.get().lsName); builder.setName(name); builder.withKey(new LocatorSetKey(name)); } else { LOG.warn("Locator Set {} not found in dump", id); } } LocatorSetCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override LocatorSetBuilder getBuilder(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier); @Override void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx); @Override List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocatorSet> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributes() throws Exception { LocatorSetBuilder builder = new LocatorSetBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); assertNotNull(builder); assertEquals("loc-set", builder.getName()); assertEquals("loc-set", builder.key().getName()); } |
LocatorSetCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<LocatorSet, LocatorSetKey, LocatorSetBuilder>, ByteDataTranslator,
LocatorSetReader, LispInitPathsMapper { @Override public List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(context)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return Collections.emptyList(); } LOG.debug("Dumping Locator Set {}", id); final Optional<OneLocatorSetDetailsReplyDump> dumpOptional = dumpManager.getDump(id, context.getModificationCache()); if (!dumpOptional.isPresent() || dumpOptional.get().oneLocatorSetDetails.isEmpty()) { return Collections.emptyList(); } return dumpOptional.get().oneLocatorSetDetails.stream() .map(set -> new LocatorSetKey(toString(set.lsName))) .collect(Collectors.toList()); } LocatorSetCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override LocatorSetBuilder getBuilder(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier); @Override void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx); @Override List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocatorSet> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext); } | @Test public void getAllIds() throws Exception { final List<LocatorSetKey> keys = getCustomizer().getAllIds(emptyId, ctx); assertEquals(1, keys.size()); assertEquals("loc-set", keys.get(0).getName()); } |
LocatorSetCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<LocatorSet, LocatorSetKey, LocatorSetBuilder>, ByteDataTranslator,
LocatorSetReader, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext) { return Initialized.create(lispLocatorSetPath(instanceIdentifier), locatorSet); } LocatorSetCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override LocatorSetBuilder getBuilder(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier); @Override void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx); @Override List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocatorSet> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext); } | @Test public void testInit(@InjectTestData(resourcePath = "/locator-set.json", id = LOC_1_PATH) LocatorSet locatorSet) { final LocatorSetKey loc1Key = new LocatorSetKey("loc1"); final KeyedInstanceIdentifier<LocatorSet, LocatorSetKey> operationalPath = InstanceIdentifier.create(LispState.class) .child(LispFeatureData.class) .child(LocatorSets.class) .child(LocatorSet.class, loc1Key); final KeyedInstanceIdentifier<LocatorSet, LocatorSetKey> configPath = InstanceIdentifier.create(Lisp.class) .child(LispFeatureData.class) .child(LocatorSets.class) .child(LocatorSet.class, loc1Key); invokeInitTest(operationalPath, locatorSet, configPath, locatorSet); } |
VrfSubtableCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VrfSubtable, VrfSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id, @Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Read attributes for {}", id); final int vni = checkNotNull(id.firstKeyOf(VniTable.class), "Cannot find parent VNI Table") .getVirtualNetworkIdentifier().intValue(); final Optional<OneEidTableMapDetailsReplyDump> reply = dumpManager.getDump(id, ctx.getModificationCache(), L3_PARAMS); if (!reply.isPresent() || reply.get().oneEidTableMapDetails.isEmpty()) { return; } final List<OneEidTableMapDetails> details = reply.get().oneEidTableMapDetails.stream().filter(a -> a.vni == vni) .collect(Collectors.toList()); if (details.size() == 1) { final OneEidTableMapDetails detail = details.get(0); builder.setTableId(Integer.valueOf(detail.dpTable).longValue()); LOG.debug("Attributes for {} successfully loaded", id); } } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Nonnull @Override VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final VrfSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VrfSubtable> instanceIdentifier, @Nonnull VrfSubtable vrfSubtable, @Nonnull ReadContext readContext); } | @Test public void testReadCurrentSuccessfull() throws ReadFailedException { doReturnValidNonEmptyDataOnDump(); VrfSubtableBuilder builder = new VrfSubtableBuilder(); customizer.readCurrentAttributes(validId, builder, ctx); verifyOneEidTableMapDumpCalled(L3); final VrfSubtable subtable = builder.build(); assertNotNull(subtable); assertEquals(expectedTableId, subtable.getTableId().longValue()); }
@Test public void testReadCurrentEmptyDump() throws ReadFailedException { doReturnEmptyDataOnDump(); VrfSubtableBuilder builder = new VrfSubtableBuilder(); customizer.readCurrentAttributes(validId, builder, ctx); verifyOneEidTableMapDumpCalled(L3); final VrfSubtable subtable = builder.build(); assertNotNull(subtable); assertNull(subtable.getTableId()); }
@Test public void testReadCurrentFailed() { doThrowOnDump(); VrfSubtableBuilder builder = new VrfSubtableBuilder(); try { customizer.readCurrentAttributes(validId, builder, ctx); } catch (ReadFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); assertTrue(builder.getTableId() == null); verifyOneEidTableMapDumpNotCalled(); return; } fail("Test should throw ReadFailedException"); } |
VrfSubtableCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VrfSubtable, VrfSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Nonnull @Override public VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id) { return new VrfSubtableBuilder(); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Nonnull @Override VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final VrfSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VrfSubtable> instanceIdentifier, @Nonnull VrfSubtable vrfSubtable, @Nonnull ReadContext readContext); } | @Override @Test public void testGetBuilder() { final VrfSubtableBuilder builder = customizer.getBuilder(validId); assertNotNull(builder); assertNull(builder.getLocalMappings()); assertNull(builder.getRemoteMappings()); assertNull(builder.getTableId()); } |
VrfSubtableCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VrfSubtable, VrfSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final VrfSubtable readValue) { ((VniTableBuilder) parentBuilder).setVrfSubtable(readValue); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Nonnull @Override VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final VrfSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VrfSubtable> instanceIdentifier, @Nonnull VrfSubtable vrfSubtable, @Nonnull ReadContext readContext); } | @Override @Test public void testMerge() { VniTableBuilder parentBuilder = new VniTableBuilder(); VrfSubtable subtable = new VrfSubtableBuilder().build(); customizer.merge(parentBuilder, subtable); assertEquals(subtable, parentBuilder.getVrfSubtable()); } |
AdjacencyCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Adjacency, AdjacencyKey, AdjacencyBuilder>, JvppReplyConsumer,
EidTranslator, LispInitPathsMapper { @Nonnull @Override public List<AdjacencyKey> getAllIds(@Nonnull final InstanceIdentifier<Adjacency> id, @Nonnull final ReadContext context) throws ReadFailedException { final int vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier().intValue(); final Optional<OneAdjacenciesGetReply> optionalDump = dumpCacheManager.getDump(id, context.getModificationCache(), new AdjacencyDumpParams(vni)); if (optionalDump.isPresent()) { return Arrays.stream(optionalDump.get().adjacencies) .map(lispAdjacency -> eidPairProducer.createPair(lispAdjacency, vni, context.getMappingContext())) .map(pair -> adjacenciesMappingContext .getAdjacencyId(pair.getLocalEidId().getValue(), pair.getRemoteEidId().getValue(), context.getMappingContext())) .map(AdjacencyKey::new) .collect(Collectors.toList()); } return Collections.emptyList(); } AdjacencyCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final EidMappingContext localMappingContext,
@Nonnull final EidMappingContext remoteMappingContext,
@Nonnull final AdjacenciesMappingContext adjacenciesMappingContext); @Nonnull @Override List<AdjacencyKey> getAllIds(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Adjacency> readData); @Nonnull @Override AdjacencyBuilder getBuilder(@Nonnull final InstanceIdentifier<Adjacency> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final AdjacencyBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Adjacency> instanceIdentifier, @Nonnull Adjacency adjacency, @Nonnull ReadContext readContext); } | @Test public void getAllIds() throws Exception { mockAddressDump(); defineEidAddressMapping(); final List<AdjacencyKey> keys = getCustomizer().getAllIds(identifier, ctx); assertThat(keys, hasSize(2)); assertThat(keys, contains(new AdjacencyKey("adj-one"), new AdjacencyKey("adj-two"))); } |
AdjacencyCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Adjacency, AdjacencyKey, AdjacencyBuilder>, JvppReplyConsumer,
EidTranslator, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id, @Nonnull final AdjacencyBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final int vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier().intValue(); final Optional<OneAdjacenciesGetReply> optionalDump = dumpCacheManager .getDump(id, ctx.getModificationCache(), new AdjacencyDumpParams(vni)); if (!optionalDump.isPresent() || optionalDump.get().adjacencies.length == 0) { return; } final String currentAdjacencyId = id.firstKeyOf(Adjacency.class).getId(); final EidIdentificatorPair currentAdjacencyIdentificationPair = adjacenciesMappingContext.getEidPair(currentAdjacencyId, ctx.getMappingContext()); final OneAdjacency currentAdjacency = Arrays.stream(optionalDump.get().adjacencies) .filter(lispAdjacency -> Objects.equals(currentAdjacencyIdentificationPair, eidPairProducer.createPair(lispAdjacency, vni, ctx.getMappingContext()))) .collect(RWUtils.singleItemCollector()); builder.setId(currentAdjacencyId) .withKey(new AdjacencyKey(currentAdjacencyId)) .setLocalEid(getArrayAsLocalEid( MappingsDumpParams.EidType.valueOf(currentAdjacency.eidType), currentAdjacency.leid, currentAdjacency.leidPrefixLen, vni)) .setRemoteEid(getArrayAsRemoteEid( MappingsDumpParams.EidType.valueOf(currentAdjacency.eidType), currentAdjacency.reid, currentAdjacency.reidPrefixLen, vni)); } AdjacencyCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final EidMappingContext localMappingContext,
@Nonnull final EidMappingContext remoteMappingContext,
@Nonnull final AdjacenciesMappingContext adjacenciesMappingContext); @Nonnull @Override List<AdjacencyKey> getAllIds(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Adjacency> readData); @Nonnull @Override AdjacencyBuilder getBuilder(@Nonnull final InstanceIdentifier<Adjacency> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final AdjacencyBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Adjacency> instanceIdentifier, @Nonnull Adjacency adjacency, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributes() throws Exception { mockAddressDump(); defineEidAddressMapping(); final AdjacencyBuilder builder = new AdjacencyBuilder(); getCustomizer().readCurrentAttributes(identifier, builder, ctx); assertEquals("adj-one", builder.getId()); assertEquals(new AdjacencyKey("adj-one"), builder.key()); assertEquals(ADDRESS_ONE.getValue(), Ipv4.class.cast(builder.getLocalEid().getAddress()).getIpv4().getValue()); assertEquals(ADDRESS_THREE.getValue(), Ipv4.class.cast(builder.getRemoteEid().getAddress()).getIpv4().getValue()); }
@Test public void readCurrentAttributesPrefixBased() throws Exception { mockPrefixDump(); defineEidPrefixMapping(); final AdjacencyBuilder builder = new AdjacencyBuilder(); getCustomizer().readCurrentAttributes(identifier, builder, ctx); assertEquals("adj-one", builder.getId()); assertEquals(new AdjacencyKey("adj-one"), builder.key()); assertEquals(NORMALIZED_PREFIX_ONE, Ipv4Prefix.class.cast(builder.getLocalEid().getAddress()).getIpv4Prefix().getValue()); assertEquals(NORMALIZED_PREFIX_THREE, Ipv4Prefix.class.cast(builder.getRemoteEid().getAddress()).getIpv4Prefix().getValue()); } |
LispStateCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<LispState, LispStateBuilder>, JvppReplyConsumer, ByteDataTranslator,
LocatorSetReader { @Override public void readCurrentAttributes(InstanceIdentifier<LispState> id, LispStateBuilder builder, ReadContext ctx) throws ReadFailedException { ShowOneStatusReply reply; try { reply = getReply(getFutureJVpp().showOneStatus(new ShowOneStatus()).toCompletableFuture()); } catch (TimeoutException | VppBaseCallException e) { throw new ReadFailedException(id, e); } builder.setEnable(byteToBoolean(reply.featureStatus)); } LispStateCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final NamingContext locatorSetContext); @Override LispStateBuilder getBuilder(InstanceIdentifier<LispState> id); @Override void readCurrentAttributes(InstanceIdentifier<LispState> id, LispStateBuilder builder, ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final LispState readValue); @Override Initialized<Lisp> init(
@Nonnull final InstanceIdentifier<LispState> id, @Nonnull final LispState readValue,
@Nonnull final ReadContext ctx); } | @Test public void testReadCurrentAttributes() throws ReadFailedException { LispStateBuilder builder = new LispStateBuilder(); getCustomizer().readCurrentAttributes(identifier, builder, ctx); assertEquals(true, builder.build().isEnable()); } |
LispStateCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<LispState, LispStateBuilder>, JvppReplyConsumer, ByteDataTranslator,
LocatorSetReader { @Override public Initialized<Lisp> init( @Nonnull final InstanceIdentifier<LispState> id, @Nonnull final LispState readValue, @Nonnull final ReadContext ctx) { final Optional<OneLocatorSetDetailsReplyDump> dumpOptional; try { dumpOptional = dumpManager.getDump(id, ctx.getModificationCache()); } catch (ReadFailedException e) { throw new IllegalStateException("Unable to initialize locator set context mapping", e); } if (dumpOptional.isPresent() && !dumpOptional.get().oneLocatorSetDetails.isEmpty()) { LOG.debug("Initializing locator set context for {}", dumpOptional.get()); dumpOptional.get().oneLocatorSetDetails .forEach(set -> { final String locatorSetName = toString(set.lsName); synchronized (locatorSetContext) { if (!locatorSetContext.containsIndex(locatorSetName, ctx.getMappingContext())) { locatorSetContext.addName(set.lsIndex, locatorSetName, ctx.getMappingContext()); } } LOG.trace("Locator Set with name: {}, VPP name: {} and index: {} found in VPP", locatorSetContext.getName(set.lsIndex, ctx.getMappingContext()), locatorSetName, set.lsIndex); }); LOG.debug("Locator set context initialized"); } return Initialized.create(InstanceIdentifier.create(Lisp.class), new LispBuilder() .setEnable(readValue.isEnable()) .setLispFeatureData(readValue.getLispFeatureData()) .build()); } LispStateCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final NamingContext locatorSetContext); @Override LispStateBuilder getBuilder(InstanceIdentifier<LispState> id); @Override void readCurrentAttributes(InstanceIdentifier<LispState> id, LispStateBuilder builder, ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final LispState readValue); @Override Initialized<Lisp> init(
@Nonnull final InstanceIdentifier<LispState> id, @Nonnull final LispState readValue,
@Nonnull final ReadContext ctx); } | @Test public void testInit(@InjectTestData(resourcePath = "/lisp-config.json") Lisp config, @InjectTestData(resourcePath = "/lisp-operational.json") LispState operational) { final InstanceIdentifier<LispState> operationalPath = InstanceIdentifier.create(LispState.class); final InstanceIdentifier<Lisp> configPath = InstanceIdentifier.create(Lisp.class); when(api.oneLocatorSetDump(any())).thenReturn(future(new OneLocatorSetDetailsReplyDump())); invokeInitTest(operationalPath, operational, configPath, config); } |
RlocProbeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator,
LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbe rlocProbe, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(RlocProbe.class), rlocProbe); } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbeBuilder rlocProbeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull ReadContext readContext); } | @Test public void testInit() { final RlocProbe data = new RlocProbeBuilder().setEnabled(true).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
RlocProbeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator,
LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbeBuilder rlocProbeBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneRlocProbeStateReply read = getReplyForRead(getFutureJVpp() .showOneRlocProbeState(new ShowOneRlocProbeState()).toCompletableFuture(), instanceIdentifier); if (read != null) { rlocProbeBuilder.setEnabled(byteToBoolean(read.isEnabled)); } } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbeBuilder rlocProbeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull ReadContext readContext); } | @Test public void testReadCurrentAttributes() throws Exception { final RlocProbeBuilder builder = new RlocProbeBuilder(); getCustomizer().readCurrentAttributes(CONFIG_IID, builder, ctx); assertTrue(builder.isEnabled()); } |
MapServerCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer,
AddressTranslator { @Nonnull @Override public List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return Collections.emptyList(); } final Optional<OneMapServerDetailsReplyDump> dump = dumpManager.getDump(instanceIdentifier, readContext.getModificationCache()); if (dump.isPresent() && dump.get().oneMapServerDetails != null) { return dump.get().oneMapServerDetails.stream() .map(detail -> arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress)) .map(MapServerKey::new) .collect(Collectors.toList()); } return Collections.emptyList(); } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull ReadContext readContext); @Nonnull @Override List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list); @Nonnull @Override MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext); } | @Test public void testGetAllIds() throws Exception { final List<MapServerKey> allIds = getCustomizer().getAllIds(STATE_IID, ctx); assertThat(allIds, hasSize(3)); assertThat(allIds, containsInAnyOrder( new MapServerKey(new IpAddress(new Ipv4AddressNoZone("192.168.2.1"))), new MapServerKey(new IpAddress(new Ipv4AddressNoZone("192.168.2.2"))), new MapServerKey(new IpAddress(new Ipv6AddressNoZone("2001:db8:a0b:12f0::1"))))); } |
MapServerCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer,
AddressTranslator { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final Optional<OneMapServerDetailsReplyDump> dump = dumpManager.getDump(instanceIdentifier, readContext.getModificationCache()); if (dump.isPresent() && dump.get().oneMapServerDetails != null) { final IpAddress currentAddress = instanceIdentifier.firstKeyOf(MapServer.class).getIpAddress(); final OneMapServerDetails currentDetail = dump.get().oneMapServerDetails.stream() .filter(detail -> currentAddress.stringValue().equalsIgnoreCase( arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress).stringValue())) .collect(RWUtils.singleItemCollector()); mapServerBuilder .setIpAddress(arrayToIpAddress(byteToBoolean(currentDetail.isIpv6), currentDetail.ipAddress)); } } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull ReadContext readContext); @Nonnull @Override List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list); @Nonnull @Override MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext); } | @Test public void testReadCurrentAttributes() throws Exception { final MapServerBuilder builder = new MapServerBuilder(); getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); assertEquals("192.168.2.1", builder.getIpAddress().getIpv4Address().getValue()); } |
MapServerCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer,
AddressTranslator { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull ReadContext readContext) { final InstanceIdentifier<MapServer> configId = InstanceIdentifier.create(Lisp.class) .child(LispFeatureData.class) .child(MapServers.class) .child(MapServer.class, instanceIdentifier.firstKeyOf(MapServer.class)); return Initialized.create(configId, mapServer); } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull ReadContext readContext); @Nonnull @Override List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list); @Nonnull @Override MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext); } | @Test public void testInit() { final MapServer data = new MapServerBuilder().setIpAddress( new IpAddress(new Ipv4Address("192.168.2.1"))).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
PetrCfgCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<PetrCfg, PetrCfgBuilder>, JvppReplyConsumer,
AddressTranslator, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfgBuilder petrCfgBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneUsePetrReply read = getReplyForRead(getFutureJVpp().showOneUsePetr(new ShowOneUsePetr()) .toCompletableFuture(), instanceIdentifier); if (read != null && read.status != 0) { petrCfgBuilder.setPetrAddress(arrayToIpAddress(!byteToBoolean(read.isIp4), read.address)); } } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull ReadContext readContext); @Nonnull @Override PetrCfgBuilder getBuilder(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfgBuilder petrCfgBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull PetrCfg petrCfg); } | @Test public void readCurrentAttributesEnabled() throws Exception { mockEnabledReply(); final PetrCfgBuilder builder = new PetrCfgBuilder(); getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); assertEquals("192.168.2.1", builder.getPetrAddress().getIpv4Address().getValue()); }
@Test public void readCurrentAttributesDisabled() throws Exception { mockDisabledReply(); final PetrCfgBuilder builder = new PetrCfgBuilder(); getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); assertNull(builder.getPetrAddress()); } |
PetrCfgCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<PetrCfg, PetrCfgBuilder>, JvppReplyConsumer,
AddressTranslator, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(PetrCfg.class), petrCfg); } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull ReadContext readContext); @Nonnull @Override PetrCfgBuilder getBuilder(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfgBuilder petrCfgBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull PetrCfg petrCfg); } | @Test public void testInit() { final PetrCfg data = new PetrCfgBuilder().setPetrAddress( new IpAddress(new Ipv4Address("192.168.2.1"))).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
RemoteMappingCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<RemoteMapping, RemoteMappingKey, RemoteMappingBuilder>,
EidTranslator, AddressTranslator, ByteDataTranslator, MappingReader, LocatorReader, LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMappingBuilder builder, ReadContext ctx) throws ReadFailedException { checkState(id.firstKeyOf(RemoteMapping.class) != null, "No key present for id({})", id); checkState(id.firstKeyOf(VniTable.class) != null, "Parent VNI table not specified"); final MappingId mappingId = id.firstKeyOf(RemoteMapping.class).getId(); checkState(remoteMappingContext.containsEid(mappingId, ctx.getMappingContext()), "No mapping stored for id %s", mappingId); final long vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier(); final Eid eid = copyEid(remoteMappingContext.getEid(mappingId, ctx.getMappingContext())); final MappingsDumpParams dumpParams = new MappingsDumpParamsBuilder() .setVni((int) vni) .setEidSet(QuantityType.SPECIFIC) .setEidType(getEidType(eid)) .setEid(getEidAsByteArray(eid)) .setPrefixLength(getPrefixLength(eid)) .setFilter(FilterType.REMOTE) .build(); LOG.debug("Dumping data for LocalMappings(id={})", id); final Optional<OneEidTableDetailsReplyDump> replyOptional = dumpManager.getDump(id, ctx.getModificationCache(), dumpParams); if (!replyOptional.isPresent() || replyOptional.get().oneEidTableDetails.isEmpty()) { return; } LOG.debug("Valid dump loaded"); OneEidTableDetails details = replyOptional.get().oneEidTableDetails.stream() .filter(subtableFilterForRemoteMappings(id)) .filter(a -> compareAddresses(eid.getAddress(), getArrayAsEidLocal(valueOf(a.eidType), a.eid, a.eidPrefixLen, a.vni).getAddress())) .collect( RWUtils.singleItemCollector()); builder.setEid(getArrayAsEidRemote(valueOf(details.eidType), details.eid, details.eidPrefixLen, details.vni)); builder.withKey(new RemoteMappingKey(new MappingId(id.firstKeyOf(RemoteMapping.class).getId()))); builder.setTtl(resolveTtl(details.ttl)); builder.setAuthoritative( new RemoteMapping.Authoritative(byteToBoolean(details.authoritative))); resolveMappings(builder, details, ctx.getModificationCache(), ctx.getMappingContext()); } RemoteMappingCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final NamingContext locatorSetContext,
@Nonnull final EidMappingContext remoteMappingContext); @Override RemoteMappingBuilder getBuilder(InstanceIdentifier<RemoteMapping> id); @Override void readCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMappingBuilder builder,
ReadContext ctx); @Override List<RemoteMappingKey> getAllIds(InstanceIdentifier<RemoteMapping> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<RemoteMapping> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RemoteMapping> instanceIdentifier,
@Nonnull RemoteMapping remoteMapping,
@Nonnull ReadContext readContext); } | @Test public void readCurrentAttributesNegativeMappingOne() throws Exception { mockAddressMappings(); mockDumpDataAddressActionOne(); RemoteMappingBuilder builder = new RemoteMappingBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); RemoteMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals(true, mapping.getAuthoritative().isA()); assertEquals(7L, mapping.getTtl().longValue()); assertTrue(mapping.getLocatorList() instanceof NegativeMapping); assertEquals(MapReplyAction.NativelyForward, ((NegativeMapping) mapping.getLocatorList()).getMapReply().getMapReplyAction()); }
@Test public void readCurrentAttributesNegativeMappingZero() throws Exception { mockAddressMappings(); mockDumpDataAddressActionZero(); RemoteMappingBuilder builder = new RemoteMappingBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); RemoteMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals(true, mapping.getAuthoritative().isA()); assertEquals(7L, mapping.getTtl().longValue()); assertEquals(MapReplyAction.NoAction, ((NegativeMapping) mapping.getLocatorList()).getMapReply().getMapReplyAction()); }
@Test public void readCurrentAttributesPrefixBasedNegativeMappingZero() throws Exception { mockPrefixMappings(); mockDumpDataPrefixActionZero(); RemoteMappingBuilder builder = new RemoteMappingBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); RemoteMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_V4_PREFIX_ADDRESS, mapping.getEid().getAddress())); assertEquals(true, mapping.getAuthoritative().isA()); assertEquals(7L, mapping.getTtl().longValue()); assertEquals(MapReplyAction.NoAction, ((NegativeMapping) mapping.getLocatorList()).getMapReply().getMapReplyAction()); }
@Test public void readCurrentAttributesPositiveMapping() throws Exception { mockAddressMappings(); mockDumpDataActionZeroWithRemotes(); RemoteMappingBuilder builder = new RemoteMappingBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); RemoteMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals(true, mapping.getAuthoritative().isA()); assertEquals(7L, mapping.getTtl().longValue()); assertTrue(mapping.getLocatorList() instanceof PositiveMapping); final List<Locator> locators = ((PositiveMapping) mapping.getLocatorList()).getRlocs().getLocator(); assertEquals(1, locators.size()); final Locator locator = locators.get(0); assertEquals("192.168.2.1", locator.getAddress().getIpv4Address().getValue()); assertEquals(1, locator.getPriority().shortValue()); assertEquals(2, locator.getWeight().shortValue()); } |
RemoteMappingCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<RemoteMapping, RemoteMappingKey, RemoteMappingBuilder>,
EidTranslator, AddressTranslator, ByteDataTranslator, MappingReader, LocatorReader, LispInitPathsMapper { @Override public List<RemoteMappingKey> getAllIds(InstanceIdentifier<RemoteMapping> id, ReadContext context) throws ReadFailedException { checkState(id.firstKeyOf(VniTable.class) != null, "Parent VNI table not specified"); final int vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier().intValue(); if (vni == 0) { return Collections.emptyList(); } final MappingsDumpParams dumpParams = new MappingsDumpParamsBuilder() .setEidSet(QuantityType.ALL) .setFilter(FilterType.REMOTE) .build(); LOG.debug("Dumping data for LocalMappings(id={})", id); final Optional<OneEidTableDetailsReplyDump> replyOptional = dumpManager.getDump(id, context.getModificationCache(), dumpParams); if (!replyOptional.isPresent() || replyOptional.get().oneEidTableDetails.isEmpty()) { return Collections.emptyList(); } return replyOptional.get() .oneEidTableDetails .stream() .filter(a -> a.vni == vni) .filter(subtableFilterForRemoteMappings(id)) .map(detail -> getArrayAsEidRemote(valueOf(detail.eidType), detail.eid, detail.eidPrefixLen, detail.vni)) .map(remoteEid -> remoteMappingContext.getId(remoteEid, context.getMappingContext())) .map(MappingId::new) .map(RemoteMappingKey::new) .collect(Collectors.toList()); } RemoteMappingCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final NamingContext locatorSetContext,
@Nonnull final EidMappingContext remoteMappingContext); @Override RemoteMappingBuilder getBuilder(InstanceIdentifier<RemoteMapping> id); @Override void readCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMappingBuilder builder,
ReadContext ctx); @Override List<RemoteMappingKey> getAllIds(InstanceIdentifier<RemoteMapping> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<RemoteMapping> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RemoteMapping> instanceIdentifier,
@Nonnull RemoteMapping remoteMapping,
@Nonnull ReadContext readContext); } | @Test public void getAllIds() throws Exception { mockAddressMappings(); mockDumpDataAddressActionOne(); final List<RemoteMappingKey> keys = getCustomizer().getAllIds(validId, ctx); assertNotNull(keys); assertEquals(1, keys.size()); assertEquals("remote-mapping", keys.get(0).getId().getValue()); } |
MapRegisterCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRegister, MapRegisterBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull MapRegisterBuilder mapRegisterBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneMapRegisterStateReply read = getReplyForRead(getFutureJVpp() .showOneMapRegisterState(new ShowOneMapRegisterState()).toCompletableFuture(), instanceIdentifier); if (read != null) { mapRegisterBuilder.setEnabled(byteToBoolean(read.isEnabled)); final ShowOneMapRegisterTtlReply ttlRead = getReplyForRead(getFutureJVpp() .showOneMapRegisterTtl(new ShowOneMapRegisterTtl()).toCompletableFuture(), instanceIdentifier); if (ttlRead != null) { mapRegisterBuilder.setTtl(UnsignedInts.toLong(ttlRead.ttl)); } final ShowOneMapRegisterFallbackThresholdReply fallbackRead = getReplyForRead( getFutureJVpp().showOneMapRegisterFallbackThreshold(new ShowOneMapRegisterFallbackThreshold()) .toCompletableFuture(), instanceIdentifier); if (fallbackRead != null) { mapRegisterBuilder.setFallbackThreshold(UnsignedInts.toLong(fallbackRead.value)); } } } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRegisterBuilder getBuilder(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegisterBuilder mapRegisterBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull MapRegister mapRegister); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull final MapRegister mapRegister,
@Nonnull final ReadContext readContext); } | @Test public void testReadCurrentAttributes() throws Exception { when(api.showOneMapRegisterTtl(any())).thenReturn(future(null)); when(api.showOneMapRegisterFallbackThreshold(any())).thenReturn(future(null)); final MapRegisterBuilder builder = new MapRegisterBuilder(); customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); assertTrue(builder.isEnabled()); assertNull(builder.getTtl()); }
@Test public void testReadCurrentAttributesWithTTLAndFallback() throws Exception { final ShowOneMapRegisterTtlReply ttlReply = new ShowOneMapRegisterTtlReply(); ttlReply.ttl = 4; final ShowOneMapRegisterFallbackThresholdReply fallbackReply = new ShowOneMapRegisterFallbackThresholdReply(); fallbackReply.value = 7; when(api.showOneMapRegisterTtl(any())).thenReturn(future(ttlReply)); when(api.showOneMapRegisterFallbackThreshold(any())).thenReturn(future(fallbackReply)); final MapRegisterBuilder builder = new MapRegisterBuilder(); customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); assertTrue(builder.isEnabled()); assertEquals(4L, builder.getTtl().longValue()); assertEquals(7L, builder.getFallbackThreshold().longValue()); } |
MapRegisterCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRegister, MapRegisterBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull final MapRegister mapRegister, @Nonnull final ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(MapRegister.class), mapRegister); } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRegisterBuilder getBuilder(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegisterBuilder mapRegisterBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull MapRegister mapRegister); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull final MapRegister mapRegister,
@Nonnull final ReadContext readContext); } | @Test public void testInit() { final MapRegister data = new MapRegisterBuilder().setEnabled(true).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
VniTableCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<VniTable, VniTableKey, VniTableBuilder>, JvppReplyConsumer { @Nonnull @Override public List<VniTableKey> getAllIds(@Nonnull final InstanceIdentifier<VniTable> id, @Nonnull final ReadContext context) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(context)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return Collections.emptyList(); } LOG.trace("Reading all IDS..."); final Optional<OneEidTableVniDetailsReplyDump> optionalReply = dumpManager.getDump(id, context.getModificationCache()); if (!optionalReply.isPresent() || optionalReply.get().oneEidTableVniDetails.isEmpty()) { return Collections.emptyList(); } return optionalReply.get().oneEidTableVniDetails.stream().map(VniTableCustomizer::detailsToKey) .collect(Collectors.toList()); } VniTableCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VniTable> readData); @Nonnull @Override VniTableBuilder getBuilder(@Nonnull final InstanceIdentifier<VniTable> id); @Nonnull @Override List<VniTableKey> getAllIds(@Nonnull final InstanceIdentifier<VniTable> id,
@Nonnull final ReadContext context); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VniTable> id,
@Nonnull final VniTableBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VniTable> instanceIdentifier, @Nonnull VniTable vniTable, @Nonnull ReadContext readContext); } | @Test public void testReadAllSuccessfull() throws ReadFailedException { whenOneEidTableVniDumpReturnValid(); final List<VniTableKey> keys = getCustomizer().getAllIds(validId, ctx); assertNotNull(keys); assertEquals(3, keys.size()); assertTrue(keys.contains(new VniTableKey(12L))); assertTrue(keys.contains(new VniTableKey(14L))); assertTrue(keys.contains(new VniTableKey(16L))); }
@Test public void testReadAllFailed() { whenOneEidTableVniDumpThrowException(); try { getCustomizer().getAllIds(validId, ctx); } catch (ReadFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); return; } fail("Test should have thrown ReadFailedException"); } |
VniTableCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<VniTable, VniTableKey, VniTableBuilder>, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VniTable> id, @Nonnull final VniTableBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } checkState(id.firstKeyOf(VniTable.class) != null, "No VNI present"); VniTableKey key = new VniTableKey(id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier()); final Optional<OneEidTableVniDetailsReplyDump> optionalReply = dumpManager.getDump(id, ctx.getModificationCache()); if (!optionalReply.isPresent() || optionalReply.get().oneEidTableVniDetails.isEmpty()) { return; } final OneEidTableVniDetails details = optionalReply.get() .oneEidTableVniDetails .stream() .filter(a -> a.vni == key.getVirtualNetworkIdentifier().intValue()) .collect(RWUtils.singleItemCollector()); builder.setVirtualNetworkIdentifier((long) details.vni); builder.withKey(new VniTableKey(Long.valueOf(details.vni))); } VniTableCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VniTable> readData); @Nonnull @Override VniTableBuilder getBuilder(@Nonnull final InstanceIdentifier<VniTable> id); @Nonnull @Override List<VniTableKey> getAllIds(@Nonnull final InstanceIdentifier<VniTable> id,
@Nonnull final ReadContext context); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VniTable> id,
@Nonnull final VniTableBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VniTable> instanceIdentifier, @Nonnull VniTable vniTable, @Nonnull ReadContext readContext); } | @Test public void testReadAttributes() throws ReadFailedException { whenOneEidTableVniDumpReturnValid(); VniTableBuilder builder = new VniTableBuilder(); customizer.readCurrentAttributes(validId, builder, ctx); final VniTable table = builder.build(); assertNotNull(table); assertEquals(12L, table.getVirtualNetworkIdentifier().longValue()); } |
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id) { return new ItrRemoteLocatorSetBuilder(); } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final ItrRemoteLocatorSet readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<ItrRemoteLocatorSet> instanceIdentifier, @Nonnull ItrRemoteLocatorSet itrRemoteLocatorSet, @Nonnull ReadContext readContext); } | @Test public void getBuilder() throws Exception { final ItrRemoteLocatorSetBuilder itrRemoteLocatorSetBuilder = getCustomizer().getBuilder(validId); assertNotNull(itrRemoteLocatorSetBuilder); assertNull(itrRemoteLocatorSetBuilder.getRemoteLocatorSetName()); } |
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id, @Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } final Optional<OneGetMapRequestItrRlocsReply> reply = dumpCacheManager.getDump(id, ctx.getModificationCache()); if (!reply.isPresent() || reply.get().locatorSetName == null) { return; } builder.setRemoteLocatorSetName(toString(reply.get().locatorSetName)); } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final ItrRemoteLocatorSet readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<ItrRemoteLocatorSet> instanceIdentifier, @Nonnull ItrRemoteLocatorSet itrRemoteLocatorSet, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributesSuccess() throws Exception { doReturnValidDataOnDump(); getCustomizer().readCurrentAttributes(validId, builder, ctx); assertNotNull(builder); assertEquals(EXPECTED_LOCATOR_SET_NAME, builder.getRemoteLocatorSetName()); verifyOneGetMapRequestItrRlocsInvokedOnce(); }
@Test public void readCurrentAttributesEmptyData() throws Exception { doReturnEmptyDataOnDump(); getCustomizer().readCurrentAttributes(validId, builder, ctx); verifyInvalidDataCase(builder); }
@Test public void readCurrentAttributesFailedCallHalted() { doThrowExceptionOnDump(); try { getCustomizer().readCurrentAttributes(validId, builder, ctx); } catch (ReadFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); assertNotNull(builder); assertNull(builder.getRemoteLocatorSetName()); verifyOneGetMapRequestItrRlocsInvokedOnce(); return; } fail("Test should have thrown exception"); } |
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final ItrRemoteLocatorSet readValue) { ((LispFeatureDataBuilder) parentBuilder).setItrRemoteLocatorSet(readValue); } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final ItrRemoteLocatorSet readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<ItrRemoteLocatorSet> instanceIdentifier, @Nonnull ItrRemoteLocatorSet itrRemoteLocatorSet, @Nonnull ReadContext readContext); } | @Test public void merge() throws Exception { LispFeatureDataBuilder builder = new LispFeatureDataBuilder(); ItrRemoteLocatorSet set = new ItrRemoteLocatorSetBuilder().setRemoteLocatorSetName("loc-set").build(); getCustomizer().merge(builder, set); assertNotNull(builder); assertEquals(set, builder.getItrRemoteLocatorSet()); } |
BridgeDomainSubtableCustomizer extends FutureJVppCustomizer implements
InitializingReaderCustomizer<BridgeDomainSubtable, BridgeDomainSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id, @Nonnull final BridgeDomainSubtableBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final int vni = checkNotNull(id.firstKeyOf(VniTable.class), "Cannot find parent VNI Table") .getVirtualNetworkIdentifier().intValue(); LOG.debug("Read attributes for id {}", id); final Optional<OneEidTableMapDetailsReplyDump> reply = dumpManager.getDump(id, ctx.getModificationCache(), L2_PARAMS); if (!reply.isPresent() || reply.get().oneEidTableMapDetails.isEmpty()) { return; } final List<OneEidTableMapDetails> details = reply.get().oneEidTableMapDetails.stream().filter(a -> a.vni == vni) .collect(Collectors.toList()); if (details.size() == 1) { final OneEidTableMapDetails detail = details.get(0); builder.setBridgeDomainRef(bridgeDomainContext.getName(detail.dpTable, ctx.getMappingContext())); LOG.debug("Attributes for {} successfully loaded", id); } } BridgeDomainSubtableCustomizer(@Nonnull final FutureJVppCore futureJvppCore,
@Nonnull final NamingContext bridgeDomainContext); @Nonnull @Override BridgeDomainSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id,
@Nonnull final BridgeDomainSubtableBuilder builder,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final BridgeDomainSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<BridgeDomainSubtable> instanceIdentifier, @Nonnull BridgeDomainSubtable bridgeDomainSubtable, @Nonnull ReadContext readContext); } | @Test public void testReadCurrentSuccessfull() throws ReadFailedException { doReturnValidNonEmptyDataOnDump(); BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); customizer.readCurrentAttributes(validId, builder, ctx); verifyOneEidTableMapDumpCalled(L2); final BridgeDomainSubtable subtable = builder.build(); assertNotNull(subtable); assertEquals("br-domain", subtable.getBridgeDomainRef()); }
@Test public void testReadCurrentEmptyDump() throws ReadFailedException { doReturnEmptyDataOnDump(); BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); customizer.readCurrentAttributes(validId, builder, ctx); verifyOneEidTableMapDumpCalled(L2); final BridgeDomainSubtable subtable = builder.build(); assertNotNull(subtable); assertNull(subtable.getBridgeDomainRef()); }
@Test public void testReadCurrentFailed() { doThrowOnDump(); BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); try { customizer.readCurrentAttributes(validId, builder, ctx); } catch (ReadFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); assertNull(builder.getBridgeDomainRef()); verifyOneEidTableMapDumpNotCalled(); return; } fail("Test should throw ReadFailedException"); } |
BridgeDomainSubtableCustomizer extends FutureJVppCustomizer implements
InitializingReaderCustomizer<BridgeDomainSubtable, BridgeDomainSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Nonnull @Override public BridgeDomainSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id) { return new BridgeDomainSubtableBuilder(); } BridgeDomainSubtableCustomizer(@Nonnull final FutureJVppCore futureJvppCore,
@Nonnull final NamingContext bridgeDomainContext); @Nonnull @Override BridgeDomainSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id,
@Nonnull final BridgeDomainSubtableBuilder builder,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final BridgeDomainSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<BridgeDomainSubtable> instanceIdentifier, @Nonnull BridgeDomainSubtable bridgeDomainSubtable, @Nonnull ReadContext readContext); } | @Override @Test public void testGetBuilder() { final BridgeDomainSubtableBuilder builder = customizer.getBuilder(validId); assertNotNull(builder); assertNull(builder.getLocalMappings()); assertNull(builder.getRemoteMappings()); assertNull(builder.getBridgeDomainRef()); } |
InterfaceCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, LocatorReader, LispInitPathsMapper { @Override public List<InterfaceKey> getAllIds(InstanceIdentifier<Interface> id, ReadContext context) throws ReadFailedException { checkState(id.firstKeyOf(LocatorSet.class) != null, "Cannot find reference to parent locator set"); final String name = id.firstKeyOf(LocatorSet.class).getName(); checkState(locatorSetContext.containsIndex(name, context.getMappingContext()), "No mapping for %s", name); final LocatorDumpParams params = new LocatorDumpParamsBuilder() .setLocatorSetIndex(locatorSetContext.getIndex(name, context.getMappingContext())).build(); final Optional<OneLocatorDetailsReplyDump> reply = dumpCacheManager.getDump(id, context.getModificationCache(), params); if (!reply.isPresent() || reply.get().oneLocatorDetails.isEmpty()) { return Collections.emptyList(); } return reply.get() .oneLocatorDetails .stream() .map(a -> new InterfaceKey(interfaceContext.getName(a.swIfIndex, context.getMappingContext()))) .collect(Collectors.toList()); } InterfaceCustomizer(@Nonnull final FutureJVppCore futureJvpp, @Nonnull final NamingContext interfaceContext,
@Nonnull final NamingContext locatorSetContext); @Override InterfaceBuilder getBuilder(InstanceIdentifier<Interface> id); @Override void readCurrentAttributes(InstanceIdentifier<Interface> id, InterfaceBuilder builder, ReadContext ctx); @Override List<InterfaceKey> getAllIds(InstanceIdentifier<Interface> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<Interface> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Interface> instanceIdentifier, @Nonnull Interface anInterface, @Nonnull ReadContext readContext); } | @Test public void testGetAllIds() throws ReadFailedException { final List<InterfaceKey> keys = getCustomizer().getAllIds(validId, ctx); assertEquals(2, keys.size()); assertEquals("interface-1", keys.get(0).getInterfaceRef()); assertEquals("interface-2", keys.get(1).getInterfaceRef()); } |
InterfaceCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, LocatorReader, LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<Interface> id, InterfaceBuilder builder, ReadContext ctx) throws ReadFailedException { final String locatorSetName = id.firstKeyOf(LocatorSet.class).getName(); final String referencedInterfaceName = id.firstKeyOf(Interface.class).getInterfaceRef(); checkState(interfaceContext.containsIndex(referencedInterfaceName, ctx.getMappingContext()), "No interface mapping for name %s", referencedInterfaceName); checkState(locatorSetContext.containsIndex(locatorSetName, ctx.getMappingContext()), "No locator set mapping for name %s", locatorSetName); final int locatorSetIndexIndex = locatorSetContext.getIndex(locatorSetName, ctx.getMappingContext()); final int referencedInterfaceIndex = interfaceContext.getIndex(referencedInterfaceName, ctx.getMappingContext()); final LocatorDumpParams params = new LocatorDumpParamsBuilder().setLocatorSetIndex(locatorSetIndexIndex).build(); final Optional<OneLocatorDetailsReplyDump> reply = dumpCacheManager.getDump(id, ctx.getModificationCache(), params); if (!reply.isPresent() || reply.get().oneLocatorDetails.isEmpty()) { return; } final OneLocatorDetails details = reply.get() .oneLocatorDetails .stream() .filter(a -> a.swIfIndex == referencedInterfaceIndex) .collect(RWUtils.singleItemCollector()); final String interfaceRef = interfaceContext.getName(details.swIfIndex, ctx.getMappingContext()); builder.setPriority((short) Byte.toUnsignedInt(details.priority)); builder.setWeight((short) Byte.toUnsignedInt(details.weight)); builder.setInterfaceRef(interfaceRef); builder.withKey(new InterfaceKey(interfaceRef)); } InterfaceCustomizer(@Nonnull final FutureJVppCore futureJvpp, @Nonnull final NamingContext interfaceContext,
@Nonnull final NamingContext locatorSetContext); @Override InterfaceBuilder getBuilder(InstanceIdentifier<Interface> id); @Override void readCurrentAttributes(InstanceIdentifier<Interface> id, InterfaceBuilder builder, ReadContext ctx); @Override List<InterfaceKey> getAllIds(InstanceIdentifier<Interface> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<Interface> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Interface> instanceIdentifier, @Nonnull Interface anInterface, @Nonnull ReadContext readContext); } | @Test public void testReadCurrentAttributes() throws ReadFailedException { InterfaceBuilder builder = new InterfaceBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); final Interface iface = builder.build(); assertEquals("interface-1", iface.getInterfaceRef()); assertEquals("interface-1", iface.key().getInterfaceRef()); } |
LocalMappingCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<LocalMapping, LocalMappingKey, LocalMappingBuilder>, EidTranslator,
MappingReader, LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMappingBuilder builder, ReadContext ctx) throws ReadFailedException { checkState(id.firstKeyOf(LocalMapping.class) != null, "No key present for id({})", id); checkState(id.firstKeyOf(VniTable.class) != null, "Parent VNI table not specified"); final MappingId mappingId = id.firstKeyOf(LocalMapping.class).getId(); checkState(localMappingContext.containsEid(mappingId, ctx.getMappingContext())); final long vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier(); final Eid eid = localMappingContext.getEid(mappingId, ctx.getMappingContext()); final MappingsDumpParams dumpParams = new MappingsDumpParams.MappingsDumpParamsBuilder() .setEidSet(QuantityType.SPECIFIC) .setVni((int) vni) .setEid(getEidAsByteArray(eid)) .setEidType(getEidType(eid)) .setPrefixLength(getPrefixLength(eid)) .build(); LOG.debug("Dumping data for LocalMappings(id={})", id); final Optional<OneEidTableDetailsReplyDump> replyOptional = dumpManager.getDump(id, ctx.getModificationCache(), dumpParams); if (!replyOptional.isPresent() || replyOptional.get().oneEidTableDetails.isEmpty()) { return; } OneEidTableDetails details = replyOptional.get().oneEidTableDetails.stream() .filter(subtableFilterForLocalMappings(id)) .filter(detail -> compareAddresses(eid.getAddress(), getAddressFromDumpDetail(detail))) .collect(RWUtils.singleItemCollector()); checkState(locatorSetContext.containsName(details.locatorSetIndex, ctx.getMappingContext()), "No Locator Set name found for index %s", details.locatorSetIndex); builder.setLocatorSet(locatorSetContext.getName(details.locatorSetIndex, ctx.getMappingContext())); builder.withKey(new LocalMappingKey(new MappingId(id.firstKeyOf(LocalMapping.class).getId()))); builder.setEid(getArrayAsEidLocal(valueOf(details.eidType), details.eid, details.eidPrefixLen, details.vni)); if (details.key != null) { builder.setHmacKey( new HmacKeyBuilder() .setKey(toString(details.key)) .setKeyType(HmacKeyType.forValue(details.keyId)) .build()); } else { builder.setHmacKey(new HmacKeyBuilder().setKeyType(HmacKeyType.NoKey).build()); } } LocalMappingCustomizer(@Nonnull FutureJVppCore futureJvpp, @Nonnull NamingContext locatorSetContext,
@Nonnull EidMappingContext localMappingsContext); @Override LocalMappingBuilder getBuilder(InstanceIdentifier<LocalMapping> id); @Override void readCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMappingBuilder builder,
ReadContext ctx); @Override List<LocalMappingKey> getAllIds(InstanceIdentifier<LocalMapping> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocalMapping> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocalMapping> instanceIdentifier, @Nonnull LocalMapping localMapping, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributesNoHmacKey() throws ReadFailedException { defineAddressMappings(); defineDumpDataNoHmacKey(); LocalMappingBuilder builder = new LocalMappingBuilder(); getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx); final LocalMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals("loc-set", mapping.getLocatorSet()); assertEquals(HmacKeyType.NoKey, mapping.getHmacKey().getKeyType()); }
@Test public void readCurrentAttributes() throws Exception { defineAddressMappings(); defineV4AddressDumpData(); LocalMappingBuilder builder = new LocalMappingBuilder(); getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx); final LocalMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals("loc-set", mapping.getLocatorSet()); final HmacKey hmacKey = mapping.getHmacKey(); assertEquals("abcdefgh", hmacKey.getKey()); assertEquals(HmacKeyType.Sha196Key, hmacKey.getKeyType()); }
@Test public void readCurrentAttributesPrefixBased() throws Exception { definePrefixMappings(); defineV4PrefixDumpData(); LocalMappingBuilder builder = new LocalMappingBuilder(); getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx); final LocalMapping mapping = builder.build(); assertNotNull(mapping); assertEquals(true, compareAddresses(EID_V4_PREFIX_ADDRESS, mapping.getEid().getAddress())); assertEquals("loc-set", mapping.getLocatorSet()); final HmacKey hmacKey = mapping.getHmacKey(); assertEquals("abcdefgh", hmacKey.getKey()); assertEquals(HmacKeyType.Sha196Key, hmacKey.getKeyType()); } |
NshMapReaderCustomizer extends FutureJVppNshCustomizer implements InitializingListReaderCustomizer<NshMap, NshMapKey, NshMapBuilder>, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<NshMap> id, @Nonnull final NshMapBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for nsh map: {}", id); final NshMapKey key = id.firstKeyOf(NshMap.class); checkArgument(key != null, "could not find NshMap key in {}", id); final NshMapDump request = new NshMapDump(); final String mapName = key.getName(); if (!nshMapContext.containsIndex(mapName, ctx.getMappingContext())) { LOG.debug("Could not find nsh map {} in the naming context", mapName); return; } request.mapIndex = nshMapContext.getIndex(mapName, ctx.getMappingContext()); final CompletionStage<NshMapDetailsReplyDump> nshMapDetailsReplyDumpCompletionStage = getFutureJVppNsh().nshMapDump(request); final NshMapDetailsReplyDump reply = getReplyForRead(nshMapDetailsReplyDumpCompletionStage.toCompletableFuture(), id); if (reply == null || reply.nshMapDetails == null || reply.nshMapDetails.isEmpty()) { LOG.debug("Has no Nsh Map {} in VPP. ", key.getName()); return; } LOG.trace("Nsh Map : {} attributes returned from VPP: {}", key.getName(), reply); final NshMapDetails nshMapDetails = reply.nshMapDetails.get(0); builder.setName(mapName); builder.withKey(key); builder.setNsp((long) ((nshMapDetails.nspNsi >> 8) & 0xFFFFFF)); builder.setNsi((short) (nshMapDetails.nspNsi & 0xFF)); builder.setMappedNsp((long) ((nshMapDetails.mappedNspNsi >> 8) & 0xFFFFFF)); builder.setMappedNsi((short) (nshMapDetails.mappedNspNsi & 0xFF)); switch (nshMapDetails.nshAction) { case 0: builder.setNshAction(Swap.class); break; case 1: builder.setNshAction(Push.class); break; case 2: builder.setNshAction(Pop.class); break; default: LOG.trace("Unsupported nsh_action for nsh map: {}", nshMapDetails.nshAction); return; } switch (nshMapDetails.nextNode) { case 2: builder.setEncapType(VxlanGpe.class); break; case 3: builder.setEncapType(Vxlan4.class); break; case 4: builder.setEncapType(Vxlan6.class); break; case 5: builder.setEncapType(None.class); break; default: LOG.trace("Unsupported encap type for nsh map: {}", nshMapDetails.nextNode); return; } if (nshMapDetails.nextNode != 5) { checkState(interfaceContext.containsName(nshMapDetails.swIfIndex, ctx.getMappingContext()), "Mapping does not contains mapping for provider interface Index "); final String interfaceName = interfaceContext.getName(nshMapDetails.swIfIndex, ctx.getMappingContext()); builder.setEncapIfName(interfaceName); } if (LOG.isTraceEnabled()) { LOG.trace("Attributes for nsh map {} successfully read: {}", id, builder.build()); } } NshMapReaderCustomizer(@Nonnull final FutureJVppNsh futureJVppNsh,
@Nonnull final NamingContext nshMapContext,
@Nonnull final NamingContext interfaceContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<NshMap> readData); @Nonnull @Override NshMapBuilder getBuilder(@Nonnull final InstanceIdentifier<NshMap> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<NshMap> id,
@Nonnull final NshMapBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<NshMapKey> getAllIds(@Nonnull final InstanceIdentifier<NshMap> id,
@Nonnull final ReadContext context); @Override Initialized<org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.nsh.rev170315.vpp.nsh.nsh.maps.NshMap> init(
@Nonnull final InstanceIdentifier<NshMap> id,
@Nonnull final NshMap readValue,
@Nonnull final ReadContext ctx); } | @Test public void testreadCurrentAttributes() throws ReadFailedException { NshMapBuilder builder = new NshMapBuilder(); getCustomizer().readCurrentAttributes(getNshMapId(MAP_NAME_1), builder, ctx); assertEquals(184, builder.getNsp().intValue()); assertEquals(255, builder.getNsi().intValue()); assertEquals(183, builder.getMappedNsp().intValue()); assertEquals(254, builder.getMappedNsi().intValue()); assertEquals(Swap.class, builder.getNshAction()); assertEquals(VxlanGpe.class, builder.getEncapType()); assertEquals("vxlanGpeTun3", builder.getEncapIfName()); verify(jvppNsh).nshMapDump(any(NshMapDump.class)); } |
LocalMappingCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<LocalMapping, LocalMappingKey, LocalMappingBuilder>, EidTranslator,
MappingReader, LispInitPathsMapper { @Override public List<LocalMappingKey> getAllIds(InstanceIdentifier<LocalMapping> id, ReadContext context) throws ReadFailedException { checkState(id.firstKeyOf(VniTable.class) != null, "Parent VNI table not specified"); final long vni = id.firstKeyOf(VniTable.class).getVirtualNetworkIdentifier(); if (vni == 0) { return Collections.emptyList(); } final MappingsDumpParams dumpParams = new MappingsDumpParamsBuilder() .setFilter(FilterType.LOCAL) .setEidSet(QuantityType.ALL) .build(); LOG.debug("Dumping data for LocalMappings(id={})", id); final Optional<OneEidTableDetailsReplyDump> replyOptional = dumpManager.getDump(id, context.getModificationCache(), dumpParams); if (!replyOptional.isPresent() || replyOptional.get().oneEidTableDetails.isEmpty()) { return Collections.emptyList(); } return replyOptional.get().oneEidTableDetails.stream() .filter(a -> a.vni == vni) .filter(subtableFilterForLocalMappings(id)) .map(detail -> getArrayAsEidLocal(valueOf(detail.eidType), detail.eid, detail.eidPrefixLen, detail.vni)) .map(localEid -> localMappingContext.getId(localEid, context.getMappingContext())) .map(MappingId::new) .map(LocalMappingKey::new) .collect(Collectors.toList()); } LocalMappingCustomizer(@Nonnull FutureJVppCore futureJvpp, @Nonnull NamingContext locatorSetContext,
@Nonnull EidMappingContext localMappingsContext); @Override LocalMappingBuilder getBuilder(InstanceIdentifier<LocalMapping> id); @Override void readCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMappingBuilder builder,
ReadContext ctx); @Override List<LocalMappingKey> getAllIds(InstanceIdentifier<LocalMapping> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocalMapping> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocalMapping> instanceIdentifier, @Nonnull LocalMapping localMapping, @Nonnull ReadContext readContext); } | @Test public void getAllIds() throws Exception { defineAddressMappings(); defineV4AddressDumpData(); final List<LocalMappingKey> keys = getCustomizer().getAllIds(emptyIdentifier, ctx); assertEquals(1, keys.size()); assertEquals("local-mapping", keys.get(0).getId().getValue()); } |
MapRequestModeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>,
JvppReplyConsumer, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestModeBuilder mapRequestModeBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneMapRequestModeReply reply = getReplyForRead( getFutureJVpp().showOneMapRequestMode(new ShowOneMapRequestMode()).toCompletableFuture(), instanceIdentifier); if (reply != null) { mapRequestModeBuilder.setMode( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.MapRequestMode .forValue(reply.mode)); } } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestModeBuilder mapRequestModeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder,
@Nonnull MapRequestMode mapRequestMode); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull ReadContext readContext); } | @Test public void testReadCurrentAttributes() throws Exception { final MapRequestModeBuilder builder = new MapRequestModeBuilder(); customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); assertEquals(DestinationOnly, builder.getMode()); } |
MapRequestModeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestMode mapRequestMode, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(MapRequestMode.class), mapRequestMode); } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestModeBuilder mapRequestModeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder,
@Nonnull MapRequestMode mapRequestMode); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull ReadContext readContext); } | @Test public void testInit() { final MapRequestMode data = new MapRequestModeBuilder().setMode(DestinationOnly).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
MapResolverCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapResolver, MapResolverKey, MapResolverBuilder>, AddressTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<MapResolver> id, MapResolverBuilder builder, ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } LOG.debug("Reading attributes..."); final Optional<OneMapResolverDetailsReplyDump> dumpOptional = dumpManager.getDump(id, ctx.getModificationCache()); if (!dumpOptional.isPresent() || dumpOptional.get().oneMapResolverDetails.isEmpty()) { LOG.warn("No data dumped"); return; } final MapResolverKey key = id.firstKeyOf(MapResolver.class); final OneMapResolverDetails mapResolverDetails = dumpOptional.get().oneMapResolverDetails.stream() .filter(a -> addressesEqual(key.getIpAddress(), arrayToIpAddress(byteToBoolean(a.isIpv6), a.ipAddress))) .collect(RWUtils.singleItemCollector()); builder.withKey(key); builder.setIpAddress( arrayToIpAddress(byteToBoolean(mapResolverDetails.isIpv6), mapResolverDetails.ipAddress)); } MapResolverCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override MapResolverBuilder getBuilder(InstanceIdentifier<MapResolver> id); @Override void readCurrentAttributes(InstanceIdentifier<MapResolver> id, MapResolverBuilder builder, ReadContext ctx); @Override List<MapResolverKey> getAllIds(InstanceIdentifier<MapResolver> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<MapResolver> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapResolver> instanceIdentifier,
@Nonnull MapResolver mapResolver, @Nonnull ReadContext readContext); } | @Test public void readCurrentAttributes() throws Exception { MapResolverBuilder builder = new MapResolverBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); MapResolver resolver = builder.build(); assertNotNull(resolver); assertEquals("1.2.168.192", resolver.getIpAddress().getIpv4Address().getValue()); } |
MapResolverCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapResolver, MapResolverKey, MapResolverBuilder>, AddressTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public List<MapResolverKey> getAllIds(InstanceIdentifier<MapResolver> id, ReadContext context) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(context)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return Collections.emptyList(); } LOG.debug("Dumping MapResolver..."); final Optional<OneMapResolverDetailsReplyDump> dumpOptional = dumpManager.getDump(id, context.getModificationCache()); if (!dumpOptional.isPresent() || dumpOptional.get().oneMapResolverDetails.isEmpty()) { return Collections.emptyList(); } return dumpOptional.get().oneMapResolverDetails.stream() .map(resolver -> new MapResolverKey( arrayToIpAddress(byteToBoolean(resolver.isIpv6), resolver.ipAddress))) .collect(Collectors.toList()); } MapResolverCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override MapResolverBuilder getBuilder(InstanceIdentifier<MapResolver> id); @Override void readCurrentAttributes(InstanceIdentifier<MapResolver> id, MapResolverBuilder builder, ReadContext ctx); @Override List<MapResolverKey> getAllIds(InstanceIdentifier<MapResolver> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<MapResolver> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapResolver> instanceIdentifier,
@Nonnull MapResolver mapResolver, @Nonnull ReadContext readContext); } | @Test public void getAllIds() throws Exception { final List<MapResolverKey> keys = getCustomizer().getAllIds(emptyId, ctx); assertEquals(1, keys.size()); final MapResolverKey key = keys.get(0); assertNotNull(key); assertEquals("1.2.168.192", key.getIpAddress().stringValue()); } |
EidMappingContext implements EidTranslator { public synchronized boolean containsEid(@Nonnull final MappingId index, @Nonnull final MappingContext mappingContext) { return mappingContext.read(getMappingIid(index)).isPresent(); } EidMappingContext(@Nonnull final String instanceName, @Nonnull final String artificialPrefix); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid remoteEid,
@Nonnull final MappingContext mappingContext); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
final MappingContext mappingContext); synchronized void removeEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized Eid getEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized boolean containsEid(@Nonnull final MappingId index,
@Nonnull final MappingContext mappingContext); } | @Test public void testContainsEid() { assertTrue(eidMappingContext.containsEid(mappingId, mappingContext)); org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.Eid loadedEid = eidMappingContext.getEid(mappingId, mappingContext); assertEquals("192.168.2.1", ((Ipv4) (loadedEid.getAddress())).getIpv4().getValue()); } |
EidMappingContext implements EidTranslator { public synchronized boolean containsId( @Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid, @Nonnull final MappingContext mappingContext) { final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class)); return read.isPresent() && read.get().getMapping() .stream() .anyMatch(mapping -> compareEids(mapping.getEid(), eid)); } EidMappingContext(@Nonnull final String instanceName, @Nonnull final String artificialPrefix); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid remoteEid,
@Nonnull final MappingContext mappingContext); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
final MappingContext mappingContext); synchronized void removeEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized Eid getEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized boolean containsEid(@Nonnull final MappingId index,
@Nonnull final MappingContext mappingContext); } | @Test public void testContainsId() { assertTrue(eidMappingContext.containsId(localEid, mappingContext)); assertTrue(eidMappingContext.containsId(remoteEid, mappingContext)); assertTrue(eidMappingContext.containsId(localPrefixBasedEid, mappingContext)); assertTrue(eidMappingContext.containsId(localPrefixBasedEidNormalized, mappingContext)); } |
EidMappingContext implements EidTranslator { public synchronized Eid getEid(@Nonnull final MappingId index, final MappingContext mappingContext) { final Optional<Mapping> read = mappingContext.read(getMappingIid(index)); checkArgument(read.isPresent(), "No mapping stored for index: %s", index); return read.get().getEid(); } EidMappingContext(@Nonnull final String instanceName, @Nonnull final String artificialPrefix); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid remoteEid,
@Nonnull final MappingContext mappingContext); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
final MappingContext mappingContext); synchronized void removeEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized Eid getEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized boolean containsEid(@Nonnull final MappingId index,
@Nonnull final MappingContext mappingContext); } | @Test public void testGetEid() { assertEquals(mappingEid, eidMappingContext.getEid(mappingId, mappingContext)); assertEquals(mappingEidPrefixBased, eidMappingContext.getEid(mappingIdPrefixBased, mappingContext)); } |
EidMappingContext implements EidTranslator { @Nonnull public synchronized MappingId getId( @Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid remoteEid, @Nonnull final MappingContext mappingContext) { final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class)); if (!read.isPresent() || !containsId(remoteEid, mappingContext)) { final MappingId artificialMappingId = getMappingId(remoteEid.toString(), artificialPrefix); addEid(artificialMappingId, remoteEid, mappingContext); return artificialMappingId; } return read.get().getMapping() .stream() .filter(mapping -> compareEids(mapping.getEid(), remoteEid)) .collect(SINGLE_ITEM_COLLECTOR).getId(); } EidMappingContext(@Nonnull final String instanceName, @Nonnull final String artificialPrefix); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid remoteEid,
@Nonnull final MappingContext mappingContext); @Nonnull synchronized MappingId getId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized boolean containsId(
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
@Nonnull final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid eid,
final MappingContext mappingContext); synchronized void addEid(
@Nonnull final MappingId index,
@Nonnull final org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.dp.subtable.grouping.remote.mappings.remote.mapping.Eid eid,
final MappingContext mappingContext); synchronized void removeEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized Eid getEid(@Nonnull final MappingId index, final MappingContext mappingContext); synchronized boolean containsEid(@Nonnull final MappingId index,
@Nonnull final MappingContext mappingContext); } | @Test public void testGetId() { assertEquals(mappingId, eidMappingContext.getId(localEid, mappingContext)); assertEquals(mappingId, eidMappingContext.getId(remoteEid, mappingContext)); assertEquals(mappingIdPrefixBased, eidMappingContext.getId(localPrefixBasedEid, mappingContext)); assertEquals(mappingIdPrefixBased, eidMappingContext.getId(localPrefixBasedEidNormalized, mappingContext)); } |
CliInbandService implements RpcService<CliInbandInput, CliInbandOutput>, JvppReplyConsumer { @Override @Nonnull public CompletionStage<CliInbandOutput> invoke(@Nonnull final CliInbandInput input) { final CliInband request = new CliInband(); request.cmd = input.getCmd(); return jvpp.cliInband(request) .thenApply(reply -> new CliInbandOutputBuilder().setReply(reply.reply).build()); } @Inject CliInbandService(@Nonnull final FutureJVppCore jvpp); @Override @Nonnull CompletionStage<CliInbandOutput> invoke(@Nonnull final CliInbandInput input); @Nonnull @Override SchemaPath getManagedNode(); } | @Test public void testInvoke() throws Exception { initMocks(this); final String replyString = "CLI output"; final CliInbandService service = new CliInbandService(api); final CliInbandReply reply = new CliInbandReply(); reply.reply = replyString; when(api.cliInband(any())).thenReturn(future(reply)); final CliInbandInput request = new CliInbandInputBuilder().setCmd("cmd").build(); final CliInbandOutput response = service.invoke(request).toCompletableFuture().get(); assertEquals(replyString, response.getReply()); } |
NamingContext implements AutoCloseable { public synchronized void addName(final int index, final String name, final MappingContext mappingContext) { final KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid = getMappingIid(name); mappingContext.put(mappingIid, new MappingBuilder().setIndex(index).setName(name).build()); } NamingContext(@Nonnull final String artificialNamePrefix, @Nonnull final String instanceName); @Nonnull synchronized String getName(final int index, @Nonnull final MappingContext mappingContext); @Nonnull synchronized Optional<String> getNameIfPresent(final int index,
@Nonnull final MappingContext mappingContext); synchronized boolean containsName(final int index, @Nonnull final MappingContext mappingContext); synchronized void addName(final int index, final String name, final MappingContext mappingContext); synchronized void addName(final String name, final MappingContext mappingContext); synchronized void removeName(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name,
final MappingContext mappingContext,
final Supplier<T> throwIfNonExisting); synchronized boolean containsIndex(final String name, final MappingContext mappingContext); @Override void close(); } | @Test public void addName() throws Exception { namingContext.addName("name-3", mappingContext); verify(mappingContext, times(1)) .put(instanceIdentifierArgumentCaptor.capture(), mappingArgumentCaptor.capture()); assertEquals(instanceIdentifierArgumentCaptor.getValue(), parentKey("name-3")); assertEquals(mappingArgumentCaptor.getValue(), new MappingBuilder() .setIndex(3) .setName("name-3") .build()); }
@Test public void addNameNoMapings() throws Exception { when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.empty()); namingContext.addName("name-0", mappingContext); verify(mappingContext, times(1)) .put(instanceIdentifierArgumentCaptor.capture(), mappingArgumentCaptor.capture()); assertEquals(instanceIdentifierArgumentCaptor.getValue(), parentKey("name-0")); assertEquals(mappingArgumentCaptor.getValue(), new MappingBuilder() .setIndex(0) .setName("name-0") .build()); } |
NamingContext implements AutoCloseable { public synchronized int getIndex(final String name, final MappingContext mappingContext) { final Optional<Mapping> read = mappingContext.read(getMappingIid(name)); checkArgument(read.isPresent(), "No mapping stored for name: %s", name); return read.get().getIndex(); } NamingContext(@Nonnull final String artificialNamePrefix, @Nonnull final String instanceName); @Nonnull synchronized String getName(final int index, @Nonnull final MappingContext mappingContext); @Nonnull synchronized Optional<String> getNameIfPresent(final int index,
@Nonnull final MappingContext mappingContext); synchronized boolean containsName(final int index, @Nonnull final MappingContext mappingContext); synchronized void addName(final int index, final String name, final MappingContext mappingContext); synchronized void addName(final String name, final MappingContext mappingContext); synchronized void removeName(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name,
final MappingContext mappingContext,
final Supplier<T> throwIfNonExisting); synchronized boolean containsIndex(final String name, final MappingContext mappingContext); @Override void close(); } | @Test(expected = IllegalArgumentException.class) public void getAndThrow() { when(mappingContext.read(any())).thenReturn(Optional.empty()); namingContext .getIndex("non-existing", mappingContext, () -> new IllegalArgumentException("Non existing index")); } |
NamingContext implements AutoCloseable { @Nonnull public synchronized Optional<String> getNameIfPresent(final int index, @Nonnull final MappingContext mappingContext) { final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class)); if (!read.isPresent()) { return Optional.empty(); } final List<Mapping> mappings = read.get().getMapping().stream() .filter(mapping -> mapping.getIndex().equals(index)) .collect(Collectors.toList()); if (mappings.size() > 1) { throw new IllegalStateException("Multiple mappings defined with index=" + index + ": " + mappings); } else if (mappings.size() == 1) { return Optional.of(mappings.get(0).getName()); } else { return Optional.empty(); } } NamingContext(@Nonnull final String artificialNamePrefix, @Nonnull final String instanceName); @Nonnull synchronized String getName(final int index, @Nonnull final MappingContext mappingContext); @Nonnull synchronized Optional<String> getNameIfPresent(final int index,
@Nonnull final MappingContext mappingContext); synchronized boolean containsName(final int index, @Nonnull final MappingContext mappingContext); synchronized void addName(final int index, final String name, final MappingContext mappingContext); synchronized void addName(final String name, final MappingContext mappingContext); synchronized void removeName(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name, final MappingContext mappingContext); synchronized int getIndex(final String name,
final MappingContext mappingContext,
final Supplier<T> throwIfNonExisting); synchronized boolean containsIndex(final String name, final MappingContext mappingContext); @Override void close(); } | @Test(expected = IllegalStateException.class) public void getNameIfPresentFails() { final Mapping mapping1 = mock(Mapping.class); final Mapping mapping2 = mock(Mapping.class); final Mappings mappings = new MappingsBuilder().setMapping(Lists.newArrayList(mapping1, mapping2)).build(); when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.of(mappings)); namingContext.getNameIfPresent(0, mappingContext); }
@Test public void getNameIfPresentReturnsAbsent() { final Mapping mapping1 = new MappingBuilder().setIndex(1).setName(NAME_1).build(); final Mappings mappings = new MappingsBuilder().setMapping(Lists.newArrayList(mapping1)).build(); when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.of(mappings)); assertEquals(Optional.empty(), namingContext.getNameIfPresent(0, mappingContext)); }
@Test public void getNameIfPresent() { final Mapping mapping1 = new MappingBuilder().setIndex(1).setName(NAME_1).build(); final Mappings mappings = new MappingsBuilder().setMapping(Lists.newArrayList(mapping1)).build(); when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.of(mappings)); assertEquals(Optional.of(NAME_1), namingContext.getNameIfPresent(1, mappingContext)); } |
VppStatusListener implements KeepaliveReaderWrapper.KeepaliveFailureListener { @Override public void onKeepaliveFailure() { LOG.error("Keepalive failed. VPP is probably DOWN! Restarting Honeycomb"); this.down = true; System.exit(RESTART_ERROR_CODE); } boolean isDown(); @Override void onKeepaliveFailure(); static final int RESTART_ERROR_CODE; } | @Test public void testOnKeepaliveFailure() throws Exception { final VppStatusListener vppStatus = new VppStatusListener(); exit.expectSystemExitWithStatus(VppStatusListener.RESTART_ERROR_CODE); exit.checkAssertionAfterwards(() -> assertTrue(vppStatus.isDown())); vppStatus.onKeepaliveFailure(); } |
MultiNamingContext { public synchronized void addChild(@Nonnull final String parentName, final int childIndex, @Nonnull final String childName, @Nonnull final MappingContext mappingContext) { checkArgument(childIndex >= startIndex, "Index cannot be lower than start index %s", startIndex); final KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid = getMappingIid(parentName); mappingContext.merge(mappingIid, new MappingBuilder().setName(parentName).setValue(Collections.singletonList(new ValueBuilder() .setIndex(childIndex) .setName(childName) .build())).build()); } MultiNamingContext(@Nonnull final String instanceName, final int startIndex); synchronized void addChild(@Nonnull final String parentName, final int childIndex,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void addChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized String getChildName(@Nonnull final String parentName,
@Nonnull final int childIndex,
@Nonnull final MappingContext mappingContext); synchronized int getChildIndex(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void removeChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); } | @Test public void addChildSpecificIndex() throws Exception { namingContext.addChild(PARENT_1, 3, CHILD_1, mappingContext); verify(mappingContext, times(1)) .merge(instanceIdentifierArgumentCaptor.capture(), mappingArgumentCaptor.capture()); assertEquals(instanceIdentifierArgumentCaptor.getValue(), parentKey(PARENT_1)); final Mapping mapping = mappingArgumentCaptor.getValue(); final List<Value> values = mapping.getValue(); assertEquals(PARENT_1, mapping.getName()); assertThat(values, hasSize(1)); final Value child = values.get(0); assertEquals(CHILD_1, child.getName()); assertEquals(3, child.getIndex().intValue()); }
@Test(expected = IllegalArgumentException.class) public void addInvalidIndex() { namingContext.addChild(PARENT_1, 2, CHILD_1, mappingContext); }
@Test public void addChildNextAvailableIndex() throws Exception { namingContext.addChild(PARENT_1, CHILD_1, mappingContext); verify(mappingContext, times(1)) .merge(instanceIdentifierArgumentCaptor.capture(), mappingArgumentCaptor.capture()); assertEquals(instanceIdentifierArgumentCaptor.getValue(), parentKey(PARENT_1)); final Mapping mapping = mappingArgumentCaptor.getValue(); final List<Value> values = mapping.getValue(); assertEquals(PARENT_1, mapping.getName()); assertThat(values, hasSize(1)); final Value child = values.get(0); assertEquals(CHILD_1, child.getName()); assertEquals(4, child.getIndex().intValue()); } |
MultiNamingContext { public synchronized String getChildName(@Nonnull final String parentName, @Nonnull final int childIndex, @Nonnull final MappingContext mappingContext) { final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); checkState(read.isPresent(), "Mapping not present"); return read.get().getValue().stream() .filter(value -> value.getIndex().equals(childIndex)) .collect(RWUtils.singleItemCollector()).getName(); } MultiNamingContext(@Nonnull final String instanceName, final int startIndex); synchronized void addChild(@Nonnull final String parentName, final int childIndex,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void addChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized String getChildName(@Nonnull final String parentName,
@Nonnull final int childIndex,
@Nonnull final MappingContext mappingContext); synchronized int getChildIndex(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void removeChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); } | @Test public void getChildName() throws Exception { assertEquals(CHILD_1, namingContext.getChildName(PARENT_1, 1, mappingContext)); } |
MultiNamingContext { public synchronized int getChildIndex(@Nonnull final String parentName, @Nonnull final String childName, @Nonnull final MappingContext mappingContext) { final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); checkState(read.isPresent(), "Mapping not present"); return read.get().getValue().stream() .filter(value -> value.getName().equals(childName)) .collect(RWUtils.singleItemCollector()).getIndex(); } MultiNamingContext(@Nonnull final String instanceName, final int startIndex); synchronized void addChild(@Nonnull final String parentName, final int childIndex,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void addChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized String getChildName(@Nonnull final String parentName,
@Nonnull final int childIndex,
@Nonnull final MappingContext mappingContext); synchronized int getChildIndex(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void removeChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); } | @Test public void getChildIndex() throws Exception { assertEquals(1, namingContext.getChildIndex(PARENT_1, CHILD_1, mappingContext)); } |
MultiNamingContext { public synchronized void removeChild(@Nonnull final String parentName, @Nonnull final String childName, @Nonnull final MappingContext mappingContext) { final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); if (read.isPresent()) { final Mapping mapping = read.get(); mappingContext.put(getMappingIid(parentName), new MappingBuilder() .setName(mapping.getName()) .withKey(mapping.key()) .setValue(mapping.getValue() .stream() .filter(value -> !value.getName().equals(childName)) .collect(Collectors.toList())) .build()); } } MultiNamingContext(@Nonnull final String instanceName, final int startIndex); synchronized void addChild(@Nonnull final String parentName, final int childIndex,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void addChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized String getChildName(@Nonnull final String parentName,
@Nonnull final int childIndex,
@Nonnull final MappingContext mappingContext); synchronized int getChildIndex(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); synchronized void removeChild(@Nonnull final String parentName,
@Nonnull final String childName,
@Nonnull final MappingContext mappingContext); } | @Test public void removeChild() throws Exception { namingContext.removeChild(PARENT_1, CHILD_1, mappingContext); verify(mappingContext, times(1)) .put(instanceIdentifierArgumentCaptor.capture(), mappingArgumentCaptor.capture()); assertEquals(instanceIdentifierArgumentCaptor.getValue(), parentKey(PARENT_1)); final Mapping mapping = mappingArgumentCaptor.getValue(); final List<Value> values = mapping.getValue(); assertEquals(PARENT_1, mapping.getName()); assertThat(values, hasSize(2)); assertThat(values, containsInAnyOrder(valueFor(CHILD_2, 2), valueFor(CHILD_3, 3))); }
@Test public void removeChildNonExistingParent() { namingContext.removeChild(NON_EXISTING_PARENT, CHILD_1, mappingContext); verify(mappingContext, times(0)).put(Mockito.any(), Mockito.any()); } |
VppCommonModule extends AbstractModule { @Override protected void configure() { install(ConfigurationModule.create()); requestInjection(VppConfigAttributes.class); bind(VppStatusListener.class).toInstance(new VppStatusListener()); bind(JVppRegistry.class).toProvider(JVppRegistryProvider.class).in(Singleton.class); bind(FutureJVppCore.class).toProvider(JVppCoreProvider.class).in(Singleton.class); bind(JVppTimeoutProvider.JVppTimeoutInit.class).toProvider(JVppTimeoutProvider.class).asEagerSingleton(); final Multibinder<ReaderFactory> readerBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class); readerBinder.addBinding().toProvider(ContextsReaderFactoryProvider.class).in(Singleton.class); } } | @Test public void testConfigure() throws Exception { initMocks(this); Guice.createInjector(new VppCommonModule(), BoundFieldModule.of(this)).injectMembers(this); assertThat(readerFactories, is(not(empty()))); assertEquals(15, JvppReplyConsumer.JvppReplyTimeoutHolder.getTimeout()); } |
ClassifySessionValidator implements Validator<ClassifySession>, ClassifyWriter { @Override public void validateWrite(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ClassifySession session, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { try { validateSession(id, writeContext); } catch (RuntimeException e) { throw new DataValidationFailedException.CreateValidationFailedException(id, session, e); } } ClassifySessionValidator(@Nonnull final VppClassifierContextManager classifyTableContext,
@Nonnull final NamingContext policerContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession session,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testWriteSuccessfull() throws CreateValidationFailedException { when(classifyTableContext.containsTable(eq(TABLE_NAME), any())).thenReturn(true); validator.validateWrite(ClassifySessionWriterTest.getClassifySessionId(TABLE_NAME, MATCH), session, writeContext); } |
ClassifySessionValidator implements Validator<ClassifySession>, ClassifyWriter { @Override public void validateDelete(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ClassifySession dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { try { validateSession(id, writeContext); } catch (RuntimeException e) { throw new DataValidationFailedException.DeleteValidationFailedException(id, e); } } ClassifySessionValidator(@Nonnull final VppClassifierContextManager classifyTableContext,
@Nonnull final NamingContext policerContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession session,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final WriteContext writeContext); } | @Test(expected = DeleteValidationFailedException.class) public void testDeleteFailedContextMissingTable() throws DeleteValidationFailedException { when(classifyTableContext.containsTable(eq(TABLE_NAME), any())).thenReturn(Boolean.FALSE); validator.validateDelete(ClassifySessionWriterTest.getClassifySessionId(TABLE_NAME, MATCH), session, writeContext); } |
SubInterfaceAclCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ingress>, AclWriter { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { setAcl(true, id, dataAfter, writeContext); } SubInterfaceAclCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceContext,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final Ingress dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testCreate() throws WriteFailedException { when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply())); customizer.writeCurrentAttributes(IID, ip4Acl(), writeContext); verify(api).inputAclSetInterface(expectedIp4AclRequest()); }
@Test(expected = WriteFailedException.class) public void testCreateFailed() throws WriteFailedException { when(api.inputAclSetInterface(any())).thenReturn(failedFuture()); customizer.writeCurrentAttributes(IID, ip4Acl(), writeContext); } |
AclCustomizer extends FutureJVppAclCustomizer implements ListWriterCustomizer<Acl, AclKey>, AclDataExtractor { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext()); if (isStandardAcl(dataBefore)) { request.deleteStandardAcl(id, dataBefore, standardAclContext); } else if (isMacIpAcl(dataBefore)) { request.deleteMacIpAcl(id, dataBefore, macIpAclContext); } else { throw new WriteFailedException.DeleteFailedException(id, new IllegalArgumentException("Unsupported acl option")); } } AclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade,
@Nonnull final AclContextManager standardAclContext,
@Nonnull final AclContextManager macIpAclContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
@Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void deleteCurrentAttributesIcmpIpv4(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclDel(aclDelRequestCaptor.capture()); assertEquals(aclIndex, aclDelRequestCaptor.getValue().aclIndex); }
@Test public void deleteCurrentAttributesIcmpIpv6( @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp-v6.json") Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclDel(aclDelRequestCaptor.capture()); assertEquals(aclIndex, aclDelRequestCaptor.getValue().aclIndex); }
@Test public void deleteCurrentAttributesTcp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp.json") Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclDel(aclDelRequestCaptor.capture()); assertEquals(aclIndex, aclDelRequestCaptor.getValue().aclIndex); }
@Test public void deleteCurrentAttributesUdp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclDel(aclDelRequestCaptor.capture()); assertEquals(aclIndex, aclDelRequestCaptor.getValue().aclIndex); } |
SubInterfaceAclCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ingress>, AclWriter { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataBefore, @Nonnull final Ingress dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new UnsupportedOperationException("Acl update is not supported. Please delete Acl container first."); } SubInterfaceAclCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceContext,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final Ingress dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final WriteContext writeContext); } | @Test(expected = UnsupportedOperationException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(IID, ip4Acl(), ip6Acl(), writeContext); } |
SubInterfaceAclCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Ingress>, AclWriter { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { setAcl(false, id, dataBefore, writeContext); } SubInterfaceAclCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceContext,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final Ingress dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testDelete() throws Exception { when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply())); customizer.deleteCurrentAttributes(IID, ip6Acl(), writeContext); verify(api).inputAclSetInterface(expectedIp6AclRequest()); }
@Test(expected = WriteFailedException.class) public void testDeleteFailed() throws WriteFailedException { when(api.inputAclSetInterface(any())).thenReturn(failedFuture()); customizer.deleteCurrentAttributes(IID, ip4Acl(), writeContext); } |
ClassifyTableValidator implements Validator<ClassifyTable>, ClassifyWriter { @Override public void validateWrite(@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTable table, @Nonnull final WriteContext writeContext) throws CreateValidationFailedException { try { validateTable(id, table); } catch (RuntimeException e) { throw new CreateValidationFailedException(id, table, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable table,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testWriteSuccessfull() throws CreateValidationFailedException { ClassifyTableBuilder builder = generatePrePopulatedClassifyTableBuilder(TABLE_NAME); validator.validateWrite(tableIID, builder.build(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedOnEmptyNBuckets() throws CreateValidationFailedException { ClassifyTableBuilder builder = generatePrePopulatedClassifyTableBuilder(TABLE_NAME); builder.setNbuckets(null); validator.validateWrite(tableIID, builder.build(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedOnEmptyMemorySize() throws CreateValidationFailedException { ClassifyTableBuilder builder = generatePrePopulatedClassifyTableBuilder(TABLE_NAME); builder.setMemorySize(null); validator.validateWrite(tableIID, builder.build(), writeContext); } |
ClassifyTableValidator implements Validator<ClassifyTable>, ClassifyWriter { @Override public void validateDelete(@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTable dataBefore, @Nonnull final WriteContext writeContext) throws DeleteValidationFailedException { try { validateTable(id, dataBefore); } catch (RuntimeException e) { throw new DeleteValidationFailedException(id, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable table,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable dataBefore,
@Nonnull final WriteContext writeContext); } | @Test(expected = DeleteValidationFailedException.class) public void testDeleteFailedOnEmptySkipNVectors() throws DeleteValidationFailedException { ClassifyTableBuilder builder = generatePrePopulatedClassifyTableBuilder(TABLE_NAME); builder.setSkipNVectors(null); validator.validateDelete(tableIID, builder.build(), writeContext); } |
ClassifySessionWriter extends VppNodeWriter implements ListWriterCustomizer<ClassifySession, ClassifySessionKey>, ByteDataTranslator, ClassifyWriter,
JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ClassifySession dataBefore, @Nonnull final ClassifySession dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new UnsupportedOperationException("Classify session update is not supported"); } ClassifySessionWriter(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext,
@Nonnull final NamingContext policerContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final ClassifySession dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final WriteContext writeContext); } | @Test(expected = UnsupportedOperationException.class) public void testUpdate() throws Exception { customizer.updateCurrentAttributes(null, null, null, writeContext); } |
ClassifySessionWriter extends VppNodeWriter implements ListWriterCustomizer<ClassifySession, ClassifySessionKey>, ByteDataTranslator, ClassifyWriter,
JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ClassifySession dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Creating classify session: iid={} dataAfter={}", id, dataAfter); try { classifyAddDelSession(true, id, dataAfter, writeContext); LOG.debug("Successfully created classify session: iid={} dataAfter={}", id, dataAfter); } catch (VppBaseCallException e) { throw new WriteFailedException.CreateFailedException(id, dataAfter, e); } } ClassifySessionWriter(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext,
@Nonnull final NamingContext policerContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final ClassifySession dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySession dataBefore,
@Nonnull final WriteContext writeContext); } | @Test(expected = IllegalStateException.class) public void testDeleteMisssingTable() throws WriteFailedException { when(writeContext.readAfter(ArgumentMatchers.any())).thenReturn(Optional.empty()); final String match = "00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00"; final ClassifySession classifySession = generateClassifySession(SESSION_INDEX, match); final InstanceIdentifier<ClassifySession> id = getClassifySessionId(TABLE_NAME, match); customizer.writeCurrentAttributes(id, classifySession, writeContext); } |
ClassifyTableWriter extends VppNodeWriter implements ListWriterCustomizer<ClassifyTable, ClassifyTableKey>, ByteDataTranslator, ClassifyWriter,
JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTable dataBefore, @Nonnull final ClassifyTable dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.error("Classify table update is not supported, ignoring config"); } ClassifyTableWriter(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable dataBefore, @Nonnull final ClassifyTable dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTable dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testUpdate() throws Exception { final ClassifyTable classifyTableBefore = generateClassifyTable(TABLE_NAME); final InstanceIdentifier<ClassifyTable> id = getClassifyTableId(TABLE_NAME); customizer.updateCurrentAttributes(id, classifyTableBefore, new ClassifyTableBuilder().build(), writeContext); verifyZeroInteractions(api); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode, @Nonnull final MappingContext ctx) { final KeyedInstanceIdentifier<ClassifyTableContext, ClassifyTableContextKey> mappingIid = getMappingIid(name); final ClassifyTableContextBuilder tableCtx = new ClassifyTableContextBuilder().setIndex(id).setName(name); if (classifierNode != null) { tableCtx.setClassifierNodeName(classifierNode.getValue()); } ctx.put(mappingIid, tableCtx.build()); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testAddTable() throws Exception { final String classfierNodeName = "node123"; vppClassfierContext.addTable(TABLE_ID_0, TABLE_NAME_0, new VppNodeName(classfierNodeName), ctx); verify(ctx).put(TABLE_IID_0, table(TABLE_ID_0, TABLE_NAME_0, classfierNodeName)); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<ClassifyTableContext> read = ctx.read(getMappingIid(name)); return read.isPresent(); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testContainsTable() throws Exception { when(ctx.read(TABLE_IID_0)).thenReturn(Optional.empty()); assertFalse(vppClassfierContext.containsTable(TABLE_NAME_0, ctx)); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<ClassifyTableContext> read = ctx.read(getMappingIid(name)); checkArgument(read.isPresent(), "No mapping stored for name: %s", name); return read.get().getIndex(); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testGetTableIndex() throws Exception { when(ctx.read(TABLE_IID_0)).thenReturn(Optional.of(table(TABLE_ID_0, TABLE_NAME_0))); assertEquals(TABLE_ID_0, vppClassfierContext.getTableIndex(TABLE_NAME_0, ctx)); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public String getTableName(final int id, @Nonnull final MappingContext ctx) { if (!containsName(id, ctx)) { final String artificialName = getArtificialName(id); addTable(id, artificialName, null, ctx); } final Optional<VppClassifierContext> read = ctx.read(VPP_CLASSIFIER_CONTEXT_IID); checkState(read.isPresent(), "VppClassifierContext for index: %s is not present. But should be", id); return read.get().getClassifyTableContext().stream() .filter(t -> t.getIndex().equals(id)) .collect(SINGLE_ITEM_COLLECTOR).getName(); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testGetTableName() throws Exception { when(ctx.read(VPP_CLASSIFIER_CONTEXT_IID)) .thenReturn(Optional.of(context(table(TABLE_ID_0, TABLE_NAME_0), table(TABLE_ID_1, TABLE_NAME_1)))); assertEquals(TABLE_NAME_0, (vppClassfierContext.getTableName(TABLE_ID_0, ctx))); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<ClassifyTableContext> read = ctx.read(getMappingIid(name)); if (read.isPresent()) { return Optional.ofNullable(read.get().getClassifierNodeName()); } return Optional.empty(); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testGetTableBaseNode() throws Exception { final String classfierNodeName = "node123"; when(ctx.read(TABLE_IID_0)).thenReturn(Optional.of(table(TABLE_ID_0, TABLE_NAME_0, classfierNodeName))); vppClassfierContext.getTableBaseNode(TABLE_NAME_0, ctx); assertEquals(Optional.of(classfierNodeName), (vppClassfierContext.getTableBaseNode(TABLE_NAME_0, ctx))); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getMappingIid(name)); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testRemoveTable() throws Exception { vppClassfierContext.removeTable(TABLE_NAME_0, ctx); verify(ctx).delete(TABLE_IID_0); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public void addNodeName(@Nonnull final String tableName, final int nodeIndex, @Nonnull final String nodeName, @Nonnull final MappingContext ctx) { final KeyedInstanceIdentifier<NodeContext, NodeContextKey> iid = getMappingIid(tableName).child(NodeContext.class, new NodeContextKey(nodeName)); ctx.put(iid, new NodeContextBuilder().setName(nodeName).setIndex(nodeIndex).build()); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testAddNodeName() throws Exception { final String nodeName = "node123"; final int nodeIndex = 1; vppClassfierContext.addNodeName(TABLE_NAME_0, nodeIndex, nodeName, ctx); verify(ctx).put( TABLE_IID_0.child(NodeContext.class, new NodeContextKey(nodeName)), node(nodeName, nodeIndex) ); } |
VppClassifierContextManagerImpl implements VppClassifierContextManager { @Override public Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx) { if (!containsName(tableIndex, ctx)) { return Optional.empty(); } final String tableName = getTableName(tableIndex, ctx); final Optional<ClassifyTableContext> tableCtx = ctx.read(getMappingIid(tableName)); final List<NodeContext> nodeContext = tableCtx.get().getNodeContext(); if (nodeContext == null) { return Optional.empty(); } return Optional.ofNullable(nodeContext.stream() .filter(n -> n.getIndex().equals(nodeIndex)) .findFirst() .map(nodes -> nodes.getName()) .orElse(null)); } VppClassifierContextManagerImpl(@Nonnull final String artificialNamePrefix); @Override void addTable(final int id, @Nonnull final String name, @Nullable final VppNodeName classifierNode,
@Nonnull final MappingContext ctx); @Override boolean containsTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override int getTableIndex(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override String getTableName(final int id, @Nonnull final MappingContext ctx); @Override Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeTable(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void addNodeName(@Nonnull final String tableName, final int nodeIndex,
@Nonnull final String nodeName,
@Nonnull final MappingContext ctx); @Override Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx); } | @Test public void testGetNonExistingNodeName() throws Exception { when(ctx.read(VPP_CLASSIFIER_CONTEXT_IID)).thenReturn(Optional.of(context(table(TABLE_ID_1, TABLE_NAME_1)))); assertFalse(vppClassfierContext.getNodeName(TABLE_ID_0, 123, ctx).isPresent()); }
@Test public void testGetNodeNameMissingNodeCtx() throws Exception { final ClassifyTableContext tableCtx = table(TABLE_ID_0, TABLE_NAME_0, "aa"); when(ctx.read(VPP_CLASSIFIER_CONTEXT_IID)).thenReturn(Optional.of(context(tableCtx))); when(ctx.read(TABLE_IID_0)).thenReturn(Optional.of(tableCtx)); assertEquals(Optional.empty(), vppClassfierContext.getNodeName(TABLE_ID_0, 123, ctx)); }
@Test public void testGetNodeName() throws Exception { final ClassifyTableContext tableCtx = table(TABLE_ID_0, TABLE_NAME_0, "aa", node("node123", 123)); when(ctx.read(VPP_CLASSIFIER_CONTEXT_IID)).thenReturn(Optional.of(context(tableCtx))); when(ctx.read(TABLE_IID_0)).thenReturn(Optional.of(tableCtx)); assertEquals(Optional.of("node123"), vppClassfierContext.getNodeName(TABLE_ID_0, 123, ctx)); } |
ClassifyTableReader extends FutureJVppCustomizer implements InitializingListReaderCustomizer<ClassifyTable, ClassifyTableKey, ClassifyTableBuilder>, VppNodeReader,
MacTranslator, InterfaceDataTranslator, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTableBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for classify table: {}", id); final ClassifyTableKey key = id.firstKeyOf(ClassifyTable.class); Preconditions.checkArgument(key != null, "could not find ClassifyTable key in {}", id); final ClassifyTableInfo request = new ClassifyTableInfo(); final String tableName = key.getName(); if (!classifyTableContext.containsTable(tableName, ctx.getMappingContext())) { LOG.debug("Could not find classify table {} in the naming context", tableName); return; } request.tableId = classifyTableContext.getTableIndex(tableName, ctx.getMappingContext()); final ClassifyTableInfoReply reply = getReplyForRead(getFutureJVpp().classifyTableInfo(request).toCompletableFuture(), id); builder.setName(tableName); builder.withKey(key); builder.setNbuckets(UnsignedInts.toLong(reply.nbuckets)); builder.setSkipNVectors(UnsignedInts.toLong(reply.skipNVectors)); final Optional<String> tableBaseNode = classifyTableContext.getTableBaseNode(tableName, ctx.getMappingContext()); if (tableBaseNode.isPresent()) { builder.setClassifierNode(new VppNodeName(tableBaseNode.get())); } final Optional<VppNode> node = readVppNode(reply.tableId, reply.missNextIndex, classifyTableContext, ctx.getMappingContext()); if (node.isPresent()) { builder.setMissNext(node.get()); } else { builder.setMissNext(new VppNode(new VppNodeName("unknown"))); } builder.setMask(new HexString(printHexBinary(reply.mask))); builder.setActiveSessions(UnsignedInts.toLong(reply.activeSessions)); if (reply.nextTableIndex != ~0) { builder.setNextTable(classifyTableContext.getTableName(reply.nextTableIndex, ctx.getMappingContext())); } if (LOG.isTraceEnabled()) { LOG.trace("Attributes for classify table {} successfully read: {}", id, builder.build()); } } ClassifyTableReader(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<ClassifyTable> readData); @Nonnull @Override ClassifyTableBuilder getBuilder(@Nonnull final InstanceIdentifier<ClassifyTable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTableBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ClassifyTableKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ReadContext context); @Override Initialized<org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.classifier.rev170327.vpp.classifier.ClassifyTable> init(
@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTable readValue,
@Nonnull final ReadContext ctx); } | @Test public void testRead() throws ReadFailedException { doReturn(future(generateClassifyTableInfoReply())).when(api).classifyTableInfo(ArgumentMatchers.any(ClassifyTableInfo.class)); when(classifierContext.containsTable(TABLE_NAME_1, mappingContext)).thenReturn(true); when(classifierContext.getTableIndex(TABLE_NAME_1, mappingContext)).thenReturn(TABLE_INDEX_1); when(classifierContext.getTableBaseNode(TABLE_NAME_1, mappingContext)).thenReturn(Optional.empty()); final ClassifyTableBuilder builder = mock(ClassifyTableBuilder.class); getCustomizer().readCurrentAttributes(getClassifyTableId(TABLE_NAME_1), builder, ctx); verifyClasifyTableRead(builder); } |
ClassifyTableReader extends FutureJVppCustomizer implements InitializingListReaderCustomizer<ClassifyTable, ClassifyTableKey, ClassifyTableBuilder>, VppNodeReader,
MacTranslator, InterfaceDataTranslator, JvppReplyConsumer { @Nonnull @Override public List<ClassifyTableKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ReadContext context) throws ReadFailedException { LOG.debug("Reading list of keys for classify tables: {}", id); final ClassifyTableIdsReply classifyTableIdsReply = getReplyForRead(getFutureJVpp().classifyTableIds(new ClassifyTableIds()).toCompletableFuture(), id); if (classifyTableIdsReply.ids != null) { return Arrays.stream(classifyTableIdsReply.ids).mapToObj(i -> { final String tableName = classifyTableContext.getTableName(i, context.getMappingContext()); LOG.trace("Classify table with name: {} and index: {} found in VPP", tableName, i); return new ClassifyTableKey(tableName); }).collect(Collectors.toList()); } else { return Collections.emptyList(); } } ClassifyTableReader(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<ClassifyTable> readData); @Nonnull @Override ClassifyTableBuilder getBuilder(@Nonnull final InstanceIdentifier<ClassifyTable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ClassifyTableBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ClassifyTableKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifyTable> id,
@Nonnull final ReadContext context); @Override Initialized<org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.classifier.rev170327.vpp.classifier.ClassifyTable> init(
@Nonnull final InstanceIdentifier<ClassifyTable> id, @Nonnull final ClassifyTable readValue,
@Nonnull final ReadContext ctx); } | @Test public void testGetAllIds() throws ReadFailedException { final ClassifyTableIdsReply reply = new ClassifyTableIdsReply(); reply.ids = new int[] {1, 2}; doReturn(future(reply)).when(api).classifyTableIds(ArgumentMatchers.any(ClassifyTableIds.class)); when(classifierContext.getTableName(TABLE_INDEX_1, mappingContext)).thenReturn(TABLE_NAME_1); when(classifierContext.getTableName(TABLE_INDEX_2, mappingContext)).thenReturn(TABLE_NAME_2); final List<ClassifyTableKey> allIds = getCustomizer().getAllIds(getClassifyTableId(TABLE_NAME_1), ctx); assertEquals(reply.ids.length, allIds.size()); assertEquals(TABLE_NAME_1, allIds.get(0).getName()); assertEquals(TABLE_NAME_2, allIds.get(1).getName()); } |
AclCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<Ingress, IngressBuilder>, AclReader, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final IngressBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for interface ACL: {}", id); final InterfaceKey interfaceKey = id.firstKeyOf(Interface.class); checkArgument(interfaceKey != null, "No parent interface key found"); final ClassifyTableByInterface request = new ClassifyTableByInterface(); request.swIfIndex = interfaceContext.getIndex(interfaceKey.getName(), ctx.getMappingContext()); final ClassifyTableByInterfaceReply reply = getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id); builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext())); builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext())); builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext())); if (LOG.isTraceEnabled()) { LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build()); } } AclCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final Ingress readValue); @Nonnull @Override IngressBuilder getBuilder(@Nonnull final InstanceIdentifier<Ingress> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final IngressBuilder builder,
@Nonnull final ReadContext ctx); @Override Initialized<Ingress> init(
@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final Ingress readValue,
@Nonnull final ReadContext ctx); } | @Test public void testRead() throws ReadFailedException { final IngressBuilder builder = mock(IngressBuilder.class); final ClassifyTableByInterfaceReply reply = new ClassifyTableByInterfaceReply(); reply.l2TableId = TABLE_INDEX; reply.ip4TableId = ~0; reply.ip6TableId = ~0; when(api.classifyTableByInterface(any())).thenReturn(future(reply)); when(classifyTableContext.getTableName(TABLE_INDEX, mappingContext)).thenReturn(TABLE_NAME); getCustomizer().readCurrentAttributes(IID, builder, ctx); verify(builder).setL2Acl(new L2AclBuilder().setClassifyTable(TABLE_NAME).build()); verify(builder).setIp4Acl(null); verify(builder).setIp6Acl(null); }
@Test(expected = ReadFailedException.class) public void testReadFailed() throws ReadFailedException { when(api.classifyTableByInterface(any())).thenReturn(failedFuture()); getCustomizer().readCurrentAttributes(IID, mock(IngressBuilder.class), ctx); } |
SubInterfaceAclCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<Ingress, IngressBuilder>, AclReader, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id, @Nonnull final IngressBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for sub-interface ACL: {}", id); final InterfaceKey parentInterfacekey = id.firstKeyOf(Interface.class); checkArgument(parentInterfacekey != null, "No parent interface key found"); final SubInterfaceKey subInterfacekey = id.firstKeyOf(SubInterface.class); checkArgument(subInterfacekey != null, "No sub-interface key found"); final String subInterfaceName = getSubInterfaceName(parentInterfacekey.getName(), subInterfacekey.getIdentifier().intValue()); final ClassifyTableByInterface request = new ClassifyTableByInterface(); request.swIfIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext()); final ClassifyTableByInterfaceReply reply = getReplyForRead(getFutureJVpp().classifyTableByInterface(request).toCompletableFuture(), id); builder.setL2Acl(readL2Acl(reply.l2TableId, classifyTableContext, ctx.getMappingContext())); builder.setIp4Acl(readIp4Acl(reply.ip4TableId, classifyTableContext, ctx.getMappingContext())); builder.setIp6Acl(readIp6Acl(reply.ip6TableId, classifyTableContext, ctx.getMappingContext())); if (LOG.isTraceEnabled()) { LOG.trace("Attributes for ACL {} successfully read: {}", id, builder.build()); } } SubInterfaceAclCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final Ingress readValue); @Nonnull @Override IngressBuilder getBuilder(@Nonnull final InstanceIdentifier<Ingress> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final IngressBuilder builder,
@Nonnull final ReadContext ctx); @Override Initialized<Ingress> init(
@Nonnull final InstanceIdentifier<Ingress> id,
@Nonnull final Ingress readValue,
@Nonnull final ReadContext ctx); } | @Test public void testRead() throws ReadFailedException { final IngressBuilder builder = mock(IngressBuilder.class); final ClassifyTableByInterfaceReply reply = new ClassifyTableByInterfaceReply(); reply.swIfIndex = SUB_IF_INDEX; reply.l2TableId = ~0; reply.ip4TableId = TABLE_INDEX; reply.ip6TableId = TABLE_INDEX; when(api.classifyTableByInterface(any())).thenReturn(future(reply)); when(classifyTableContext.getTableName(TABLE_INDEX, mappingContext)).thenReturn(TABLE_NAME); getCustomizer().readCurrentAttributes(IID, builder, ctx); verify(builder).setL2Acl(null); verify(builder).setIp4Acl(new Ip4AclBuilder().setClassifyTable(TABLE_NAME).build()); verify(builder).setIp6Acl(new Ip6AclBuilder().setClassifyTable(TABLE_NAME).build()); }
@Test(expected = ReadFailedException.class) public void testReadFailed() throws ReadFailedException { when(api.classifyTableByInterface(any())).thenReturn(failedFuture()); getCustomizer().readCurrentAttributes(IID, mock(IngressBuilder.class), ctx); } |
ClassifySessionReader extends FutureJVppCustomizer implements ListReaderCustomizer<ClassifySession, ClassifySessionKey, ClassifySessionBuilder>,
InterfaceDataTranslator, VppNodeReader, JvppReplyConsumer { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ClassifySessionBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading attributes for classify session: {}", id); final ClassifySessionKey key = id.firstKeyOf(ClassifySession.class); Preconditions.checkArgument(key != null, "could not find ClassifySession key in {}", id); final ClassifySessionDetailsReplyDump classifySessionDump = dumpClassifySessions(id, ctx); final byte[] match = DatatypeConverter.parseHexBinary(key.getMatch().getValue().replace(":", "")); final Optional<ClassifySessionDetails> classifySession = findClassifySessionDetailsByMatch(classifySessionDump, match); if (classifySession.isPresent()) { final ClassifySessionDetails detail = classifySession.get(); final Optional<VppNode> node = readVppNode(detail.tableId, detail.hitNextIndex, classifyTableContext, ctx.getMappingContext()); final StandardBuilder nextNode = new StandardBuilder(); if (node.isPresent()) { nextNode.setHitNext(node.get()); } else { nextNode.setHitNext(new VppNode(new VppNodeName("unknown"))); } if (detail.opaqueIndex != ~0) { nextNode.setOpaqueIndex(readOpaqueIndex(detail.tableId, detail.opaqueIndex, ctx.getMappingContext())); } builder.setNextNode(nextNode.build()); builder.setAdvance(detail.advance); builder.setMatch(key.getMatch()); if (LOG.isTraceEnabled()) { LOG.trace("Attributes for classify session {} successfully read: {}", id, builder.build()); } } } ClassifySessionReader(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<ClassifySession> readData); @Nonnull @Override ClassifySessionBuilder getBuilder(@Nonnull final InstanceIdentifier<ClassifySession> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySessionBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ClassifySessionKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ReadContext ctx); } | @Test public void testReadWithCache() throws ReadFailedException { final InstanceIdentifier<ClassifySession> id = getClassifySessionId(TABLE_NAME, MATCH_1); final ClassifySessionBuilder builder = mock(ClassifySessionBuilder.class); final ModificationCache cache = new ModificationCache(); final ClassifySessionDetailsReplyDump dump = new ClassifySessionDetailsReplyDump(); final ClassifySessionDetails details = new ClassifySessionDetails(); details.match = new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, 0x00, 0x00, 0x00, 0x00}; dump.classifySessionDetails = Collections.singletonList(details); cache.put(ClassifySessionReader.CACHE_KEY + id.firstKeyOf(ClassifyTable.class), dump); when(ctx.getModificationCache()).thenReturn(cache); getCustomizer().readCurrentAttributes(id, builder, ctx); } |
ClassifySessionReader extends FutureJVppCustomizer implements ListReaderCustomizer<ClassifySession, ClassifySessionKey, ClassifySessionBuilder>,
InterfaceDataTranslator, VppNodeReader, JvppReplyConsumer { @Nonnull @Override public List<ClassifySessionKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifySession> id, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading list of keys for classify sessions: {}", id); final ClassifySessionDetailsReplyDump classifySessionDump = dumpClassifySessions(id, ctx); if (classifySessionDump != null && classifySessionDump.classifySessionDetails != null) { return classifySessionDump.classifySessionDetails.stream() .map(detail -> new ClassifySessionKey(new HexString(printHexBinary(detail.match)))) .collect(Collectors.toList()); } else { return Collections.emptyList(); } } ClassifySessionReader(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final VppClassifierContextManager classifyTableContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<ClassifySession> readData); @Nonnull @Override ClassifySessionBuilder getBuilder(@Nonnull final InstanceIdentifier<ClassifySession> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ClassifySessionBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ClassifySessionKey> getAllIds(@Nonnull final InstanceIdentifier<ClassifySession> id,
@Nonnull final ReadContext ctx); } | @Test public void testGetAllIds() throws ReadFailedException { final InstanceIdentifier<ClassifySession> id = getClassifySessionId(TABLE_NAME, MATCH_1); final ClassifySessionDetailsReplyDump dump = new ClassifySessionDetailsReplyDump(); final ClassifySessionDetails details1 = new ClassifySessionDetails(); details1.match = new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, 0x00, 0x00, 0x00, 0x00}; final ClassifySessionDetails details2 = new ClassifySessionDetails(); details2.match = new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x07, 0x00, 0x00, 0x00, 0x00}; dump.classifySessionDetails = Arrays.asList(details1, details2); doReturn(future(dump)).when(api).classifySessionDump(ArgumentMatchers.any(ClassifySessionDump.class)); when(classifierContext.containsTable(TABLE_NAME, mappingContext)).thenReturn(true); when(classifierContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX); final List<ClassifySessionKey> allIds = getCustomizer().getAllIds(id, ctx); assertEquals(2, allIds.size()); assertEquals(MATCH_1, allIds.get(0).getMatch().getValue()); assertEquals(MATCH_2, allIds.get(1).getMatch().getValue()); } |
PolicerValidator implements Validator<Policer> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Policer> id, @Nonnull final Policer policer, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { try { validatePolicer(policer); } catch (RuntimeException e) { throw new DataValidationFailedException.CreateValidationFailedException(id, policer, e); } } PolicerValidator(final NamingContext policerContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Policer> id,
@Nonnull final Policer policer,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Policer> id,
@Nonnull final Policer policer,
@Nonnull final WriteContext writeContext); } | @Test public void testWriteSuccessfull() throws CreateValidationFailedException { PolicerBuilder builder = generatePrePopulatedPolicerBuilder(); validator.validateWrite(POLICER_IID, builder.build(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedDscp() throws CreateValidationFailedException { PolicerBuilder builder = generatePrePopulatedPolicerBuilder(); builder.setConformAction(generateConformAction(true, MeterActionDrop.class)); validator.validateWrite(POLICER_IID, builder.build(), writeContext); } |
PolicerValidator implements Validator<Policer> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Policer> id, @Nonnull final Policer policer, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { try { validatePolicer(policer); } catch (RuntimeException e) { throw new DataValidationFailedException.DeleteValidationFailedException(id, e); } } PolicerValidator(final NamingContext policerContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Policer> id,
@Nonnull final Policer policer,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Policer> id,
@Nonnull final Policer policer,
@Nonnull final WriteContext writeContext); } | @Test(expected = DeleteValidationFailedException.class) public void testDeleteFailedDscp() throws DeleteValidationFailedException { PolicerBuilder builder = generatePrePopulatedPolicerBuilder(); builder.setExceedAction(generateExceedAction(true, MeterActionTransmit.class)); validator.validateDelete(POLICER_IID, builder.build(), writeContext); } |
Ikev2PolicyCustomizer extends FutureJVppIkev2Customizer implements ListWriterCustomizer<Policy, PolicyKey>, JvppReplyConsumer, ByteDataTranslator, Ipv4Translator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final Ikev2ProfileAddDel request = new Ikev2ProfileAddDel(); request.isAdd = BYTE_TRUE; request.name = dataAfter.getName().getBytes(); getReplyForWrite(getjVppIkev2Facade().ikev2ProfileAddDel(request).toCompletableFuture(), id); addAuthorization(dataAfter, id); addTrafficSelectors(dataAfter, id); } Ikev2PolicyCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testWrite(@InjectTestData(resourcePath = "/ikev2/addIkev2Profile.json", id = IKEV2_PATH) Ikev2 ikev2) throws WriteFailedException { Policy policy = ikev2.getPolicy().get(0); customizer.writeCurrentAttributes(getId(policy.getName()), policy, writeContext); Ikev2ProfileAddDel profileAddrequest = new Ikev2ProfileAddDel(); profileAddrequest.isAdd = BYTE_TRUE; profileAddrequest.name = policy.getName().getBytes(); verify(ikev2api).ikev2ProfileAddDel(profileAddrequest); verify(ikev2api).ikev2ProfileSetTs(translateTStoRequest(policy.augmentation(IpsecIkev2PolicyAugmentation.class) .getTrafficSelectors().get(0), policy.getName())); verify(ikev2api).ikev2ProfileSetAuth(translateAuthToRequest(policy)); } |
Ikev2PolicyCustomizer extends FutureJVppIkev2Customizer implements ListWriterCustomizer<Policy, PolicyKey>, JvppReplyConsumer, ByteDataTranslator, Ipv4Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore, @Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { addAuthorization(dataAfter, id); addTrafficSelectors(dataAfter, id); } Ikev2PolicyCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testUpdate( @InjectTestData(resourcePath = "/ikev2/addDelProfile_before.json", id = IKEV2_PATH) Ikev2 ikev2Before, @InjectTestData(resourcePath = "/ikev2/addDelProfile_after.json", id = IKEV2_PATH) Ikev2 ikev2After) throws WriteFailedException { final Policy before = ikev2Before.getPolicy().get(0); final Policy after = ikev2After.getPolicy().get(0); customizer.updateCurrentAttributes(getId(before.getName()), before, after, writeContext); verify(ikev2api, times(0)).ikev2ProfileAddDel(any()); verify(ikev2api).ikev2ProfileSetTs(translateTStoRequest(after.augmentation(IpsecIkev2PolicyAugmentation.class) .getTrafficSelectors().get(0), after.getName())); verify(ikev2api).ikev2ProfileSetAuth(translateAuthToRequest(after)); } |
Ikev2PolicyCustomizer extends FutureJVppIkev2Customizer implements ListWriterCustomizer<Policy, PolicyKey>, JvppReplyConsumer, ByteDataTranslator, Ipv4Translator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final Ikev2ProfileAddDel request = new Ikev2ProfileAddDel(); request.isAdd = BYTE_FALSE; request.name = dataBefore.getName().getBytes(); getReplyForWrite(getjVppIkev2Facade().ikev2ProfileAddDel(request).toCompletableFuture(), id); } Ikev2PolicyCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataBefore,
@Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testDelete(@InjectTestData(resourcePath = "/ikev2/addIkev2Profile.json", id = IKEV2_PATH) Ikev2 ikev2) throws WriteFailedException { Policy policy = ikev2.getPolicy().get(0); customizer.deleteCurrentAttributes(getId(policy.getName()), policy, writeContext); final Ikev2ProfileAddDel request = new Ikev2ProfileAddDel(); request.name = policy.getName().getBytes(); request.isAdd = BYTE_FALSE; verify(ikev2api).ikev2ProfileAddDel(request); verify(ikev2api, times(0)).ikev2ProfileSetTs(any()); verify(ikev2api, times(0)).ikev2ProfileSetAuth(any()); } |
IpsecSadEntryCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SadEntries, SadEntriesKey>,
JvppReplyConsumer, ByteDataTranslator, Ipv6Translator, Ipv4Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id, @Nonnull final SadEntries dataBefore, @Nonnull final SadEntries dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { writeCurrentAttributes(id, dataAfter, writeContext); } IpsecSadEntryCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataBefore,
@Nonnull final SadEntries dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testUpdate( @InjectTestData(resourcePath = "/sadEntries/addDelSadEntry_Ipv6_before.json", id = SAD_PATH) Sad relaysBefore, @InjectTestData(resourcePath = "/sadEntries/addDelSadEntry_Ipv6_after.json", id = SAD_PATH) Sad relayAfter) throws WriteFailedException { final SadEntries before = relaysBefore.getSadEntries().get(0); final SadEntries after = relayAfter.getSadEntries().get(0); final Long spi = after.getSpi(); customizer.updateCurrentAttributes(getId(IpsecTrafficDirection.Outbound, spi), before, after, writeContext); final IpsecSadEntryAddDel request = new IpsecSadEntryAddDel(); request.isAdd = BYTE_TRUE; request.entry = new IpsecSadEntry(); request.entry.spi = SPI_1002; request.entry.sadId = SAD_ID; request.entry.protocol = IpsecProto.IPSEC_API_PROTO_AH; request.entry.integrityAlgorithm = IpsecIntegAlg.IPSEC_API_INTEG_ALG_MD5_96; request.entry.integrityKey = new Key(); request.entry.integrityKey.data = INTEG_KEY.getBytes(); request.entry.integrityKey.length = (byte) INTEG_KEY.getBytes().length; request.entry.cryptoAlgorithm = IpsecCryptoAlg.IPSEC_API_CRYPTO_ALG_NONE; request.entry.cryptoKey = new Key(); request.entry.cryptoKey.data = null; request.entry.cryptoKey.length = 0; request.entry.flags = new IpsecSadFlags(); request.entry.flags.add(IpsecSadFlags.IpsecSadFlagsOptions.IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY); request.entry.tunnelSrc = ipv6AddressToAddress(Ipv6Address.getDefaultInstance("2001::11")); request.entry.tunnelDst = ipv6AddressToAddress(Ipv6Address.getDefaultInstance("2001::12")); verify(api).ipsecSadEntryAddDel(request); } |
IpsecSadEntryCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SadEntries, SadEntriesKey>,
JvppReplyConsumer, ByteDataTranslator, Ipv6Translator, Ipv4Translator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id, @Nonnull final SadEntries dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { addDelEntry(id, dataBefore, writeContext, false); } IpsecSadEntryCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataBefore,
@Nonnull final SadEntries dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SadEntries> id,
@Nonnull final SadEntries dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testDelete(@InjectTestData(resourcePath = "/sadEntries/delSadEntry.json", id = SAD_PATH) Sad sad) throws WriteFailedException { final SadEntries data = sad.getSadEntries().get(0); final Long spi = data.getSpi(); customizer.deleteCurrentAttributes(getId(IpsecTrafficDirection.Outbound, spi), data, writeContext); final IpsecSadEntryAddDel request = new IpsecSadEntryAddDel(); request.isAdd = BYTE_FALSE; request.entry = new IpsecSadEntry(); request.entry.spi = SPI_1002; request.entry.sadId = SAD_ID; request.entry.flags = new IpsecSadFlags(); verify(api).ipsecSadEntryAddDel(request); } |
Ikev2PolicyIdentityCustomizer extends FutureJVppIkev2Customizer implements WriterCustomizer<Identity>, JvppReplyConsumer, ByteDataTranslator, Ipv4Translator, Ipv6Translator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id, @Nonnull final Identity dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { String name = id.firstKeyOf(Policy.class).getName(); if (dataAfter.getLocal() != null) { setProfileId(id, name, dataAfter.getLocal().getIdentity(), true); } if (dataAfter.getRemote() != null) { setProfileId(id, name, dataAfter.getRemote().getIdentity(), false); } } Ikev2PolicyIdentityCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataBefore,
@Nonnull final Identity dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testWriteLocalIpv4( @InjectTestData(resourcePath = "/ikev2/identity/identity_local_ipv4.json", id = IDENTITY_PATH) Identity identity) throws WriteFailedException { customizer.writeCurrentAttributes(getId(), identity, writeContext); Ikev2ProfileSetId request = new Ikev2ProfileSetId(); request.name = POLICY_NAME.getBytes(); request.idType = (byte) 1; request.isLocal = BYTE_TRUE; request.data = ipv4AddressNoZoneToArray(IPV4_TYPE_DATA); request.dataLen = request.data.length; verify(ikev2api).ikev2ProfileSetId(request); }
@Test public void testWriteRemoteFqdn( @InjectTestData(resourcePath = "/ikev2/identity/identity_remote_fqdn.json", id = IDENTITY_PATH) Identity identity) throws WriteFailedException { customizer.writeCurrentAttributes(getId(), identity, writeContext); Ikev2ProfileSetId request = new Ikev2ProfileSetId(); request.name = POLICY_NAME.getBytes(); request.idType = (byte) 2; request.isLocal = BYTE_FALSE; request.data = FQDN_TYPE_DATA.getBytes(); request.dataLen = request.data.length; verify(ikev2api).ikev2ProfileSetId(request); }
@Test public void testWriteLocalIpv6( @InjectTestData(resourcePath = "/ikev2/identity/identity_remote_ipv6.json", id = IDENTITY_PATH) Identity identity) throws WriteFailedException { customizer.writeCurrentAttributes(getId(), identity, writeContext); Ikev2ProfileSetId request = new Ikev2ProfileSetId(); request.name = POLICY_NAME.getBytes(); request.idType = (byte) 5; request.isLocal = BYTE_FALSE; request.data = ipv6AddressNoZoneToArray(new Ipv6Address(IPV6_TYPE_DATA)); request.dataLen = request.data.length; verify(ikev2api).ikev2ProfileSetId(request); } |
AclValidator implements Validator<Acl>, AclDataExtractor { @Override public void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx) throws CreateValidationFailedException { try { validateAcl(dataAfter); } catch (RuntimeException e) { throw new CreateValidationFailedException(id, dataAfter, e); } } @Override void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx); @Override void validateUpdate(final InstanceIdentifier<Acl> id, final Acl dataBefore, final Acl dataAfter,
final WriteContext ctx); @Override void validateDelete(final InstanceIdentifier<Acl> id, final Acl dataBefore, final WriteContext ctx); } | @Test public void testValidateWrite( @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") Acls acls) throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(ID, acls.getAcl().get(0), writeContext); }
@Test(expected = DataValidationFailedException.CreateValidationFailedException.class) public void testValidateWriteEmptyAcl() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(ID, new AclBuilder().build(), writeContext); } |
Ikev2PolicyIdentityCustomizer extends FutureJVppIkev2Customizer implements WriterCustomizer<Identity>, JvppReplyConsumer, ByteDataTranslator, Ipv4Translator, Ipv6Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id, @Nonnull final Identity dataBefore, @Nonnull final Identity dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { writeCurrentAttributes(id, dataAfter, writeContext); } Ikev2PolicyIdentityCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataBefore,
@Nonnull final Identity dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Identity> id,
@Nonnull final Identity dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testUpdate( @InjectTestData(resourcePath = "/ikev2/identity/identity_local_ipv4.json", id = IDENTITY_PATH) Identity before, @InjectTestData(resourcePath = "/ikev2/identity/identity_local_rfc822.json", id = IDENTITY_PATH) Identity after) throws WriteFailedException { customizer.updateCurrentAttributes(getId(), before, after, writeContext); Ikev2ProfileSetId request = new Ikev2ProfileSetId(); request.name = POLICY_NAME.getBytes(); request.idType = (byte) 3; request.isLocal = BYTE_TRUE; request.data = RFC822_TYPE_DATA.getBytes(); request.dataLen = request.data.length; verify(ikev2api).ikev2ProfileSetId(request); } |
Ikev2GlobalConfigurationCustomizer extends FutureJVppIkev2Customizer implements WriterCustomizer<IkeGlobalConfiguration>, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<IkeGlobalConfiguration> id, @Nonnull final IkeGlobalConfiguration dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { IpsecIkeGlobalConfAugmentation fileAUg = dataAfter.augmentation(IpsecIkeGlobalConfAugmentation.class); if (fileAUg != null) { if (fileAUg.getLocalKeyFile() != null) { Ikev2SetLocalKey request = new Ikev2SetLocalKey(); request.keyFile = fileAUg.getLocalKeyFile().getBytes(); getReplyForWrite(getjVppIkev2Facade().ikev2SetLocalKey(request).toCompletableFuture(), id); } } } Ikev2GlobalConfigurationCustomizer(final FutureJVppIkev2Facade vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<IkeGlobalConfiguration> id,
@Nonnull final IkeGlobalConfiguration dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<IkeGlobalConfiguration> id,
@Nonnull final IkeGlobalConfiguration dataBefore,
@Nonnull final IkeGlobalConfiguration dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<IkeGlobalConfiguration> id,
@Nonnull final IkeGlobalConfiguration dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testWrite() throws WriteFailedException { IkeGlobalConfigurationBuilder dataAfterBuilder = new IkeGlobalConfigurationBuilder(); IpsecIkeGlobalConfAugmentationBuilder augBuilder = new IpsecIkeGlobalConfAugmentationBuilder(); augBuilder.setLocalKeyFile(LOCAL_KEY_FILE); dataAfterBuilder.addAugmentation(IpsecIkeGlobalConfAugmentation.class, augBuilder.build()); customizer.writeCurrentAttributes(IID, dataAfterBuilder.build(), writeContext); Ikev2SetLocalKey request = new Ikev2SetLocalKey(); request.keyFile = LOCAL_KEY_FILE.getBytes(); verify(ikev2api).ikev2SetLocalKey(request); } |
IpsecSpdCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Spd, SpdKey>, JvppReplyConsumer, ByteDataTranslator,
Ipv6Translator, Ipv4Translator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { IpsecSpdAddDel spdCreate = new IpsecSpdAddDel(); spdCreate.isAdd = ByteDataTranslator.BYTE_TRUE; spdCreate.spdId = dataAfter.getSpdId(); getReplyForWrite(getFutureJVpp().ipsecSpdAddDel(spdCreate).toCompletableFuture(), id); if (dataAfter.getSpdEntries() != null) { for (SpdEntries entry : dataAfter.getSpdEntries()) { addSpdEntry(id, dataAfter.getSpdId(), entry); } } } IpsecSpdCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final Spd dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testWrite(@InjectTestData(resourcePath = "/spdEntries/addDelSpd.json", id = IPSEC_PATH) Ipsec ipsec) throws WriteFailedException { Spd spd = ipsec.getSpd().get(0); customizer.writeCurrentAttributes(getSpdId(SPD_ID), spd, writeContext); final IpsecSpdAddDel createSpdRequest = new IpsecSpdAddDel(); createSpdRequest.isAdd = BYTE_TRUE; createSpdRequest.spdId = SPD_ID; verify(api).ipsecSpdAddDel(createSpdRequest); verify(api).ipsecSpdEntryAddDel(translateSpdEntry(spd.getSpdEntries().get(0), SPD_ID, true)); verify(api).ipsecSpdEntryAddDel(translateSpdEntry(spd.getSpdEntries().get(1), SPD_ID, true)); } |
IpsecSpdCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Spd, SpdKey>, JvppReplyConsumer, ByteDataTranslator,
Ipv6Translator, Ipv4Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore, @Nonnull final Spd dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (dataAfter.getSpdEntries() != null) { for (SpdEntries entry : dataAfter.getSpdEntries()) { addSpdEntry(id, dataAfter.getSpdId(), entry); } } } IpsecSpdCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final Spd dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testUpdate( @InjectTestData(resourcePath = "/spdEntries/addDelSpd_before.json", id = IPSEC_PATH) Ipsec ipsecBefore, @InjectTestData(resourcePath = "/spdEntries/addDelSpd_after.json", id = IPSEC_PATH) Ipsec ipsecAfter) throws WriteFailedException { Spd before = ipsecBefore.getSpd().get(0); Spd after = ipsecAfter.getSpd().get(0); customizer.updateCurrentAttributes(getSpdId(SPD_ID), before, after, writeContext); verify(api).ipsecSpdEntryAddDel(translateSpdEntry(after.getSpdEntries().get(0), SPD_ID, true)); } |
IpsecSpdCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Spd, SpdKey>, JvppReplyConsumer, ByteDataTranslator,
Ipv6Translator, Ipv4Translator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { IpsecSpdAddDel spdDelete = new IpsecSpdAddDel(); spdDelete.isAdd = ByteDataTranslator.BYTE_FALSE; spdDelete.spdId = dataBefore.getSpdId(); getReplyForWrite(getFutureJVpp().ipsecSpdAddDel(spdDelete).toCompletableFuture(), id); } IpsecSpdCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final Spd dataBefore,
@Nonnull final Spd dataAfter, @Nonnull final WriteContext writeContext); } | @Test public void testDelete() throws WriteFailedException { SpdBuilder spdBuilder = new SpdBuilder(); spdBuilder.setSpdId(SPD_ID) .withKey(new SpdKey(SPD_ID)) .setSpdEntries(Collections.singletonList(new SpdEntriesBuilder().build())); customizer.deleteCurrentAttributes(getSpdId(SPD_ID), spdBuilder.build(), writeContext); IpsecSpdAddDel request = new IpsecSpdAddDel(); request.spdId = SPD_ID; request.isAdd = BYTE_FALSE; verify(api).ipsecSpdAddDel(request); } |
IpsecStateCustomizer extends FutureJVppCustomizer implements JvppReplyConsumer, InitializingReaderCustomizer<IpsecState, IpsecStateBuilder>, Ipv4Translator,
Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<IpsecState> id, @Nonnull final IpsecStateBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final Optional<IpsecSaDetailsReplyDump> dumpSa = ipsecSaDetailsReplyDumpManager.getDump(id, ctx.getModificationCache()); if (dumpSa.isPresent()) { LinkedList<Sa> listSa = new LinkedList<>(); IpsecSaDetailsReplyDump reply = dumpSa.get(); for (IpsecSaDetails details : reply.ipsecSaDetails) { SaBuilder saBuilder = new SaBuilder(); saBuilder.setSpi(Integer.toUnsignedLong(details.entry.spi)) .setAntiReplayWindow((int) details.replayWindow) .setAuthenticationAlgorithm(parseAuthAlgorithm(details.entry.integrityAlgorithm)) .setEncryptionAlgorithm(parseCryptoAlgorithm(details.entry.cryptoAlgorithm)); listSa.add(saBuilder.build()); } builder.setSa(listSa); } } IpsecStateCustomizer(final FutureJVppCore vppApi); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<IpsecState> id,
@Nonnull final IpsecState readValue, @Nonnull final ReadContext ctx); @Nonnull @Override IpsecStateBuilder getBuilder(@Nonnull final InstanceIdentifier<IpsecState> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<IpsecState> id,
@Nonnull final IpsecStateBuilder builder,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final IpsecState readValue); } | @Test public void testReadSa() throws ReadFailedException { final IpsecStateBuilder builder = new IpsecStateBuilder(); getCustomizer().readCurrentAttributes(IPSEC_STATE_ID, builder, ctx); assertEquals(builder.getSa().size(), 1); Sa sa = builder.getSa().get(0); assertEquals(sa.getAntiReplayWindow().intValue(), REPLY_WINDOW); assertEquals(sa.getAuthenticationAlgorithm().getIntValue(), INTEG_ALG); assertEquals(sa.getEncryptionAlgorithm(), IkeEncryptionAlgorithmT.EncrAesCbc128); assertEquals(sa.getSpi().intValue(), SPI); } |
IpsecStateCustomizer extends FutureJVppCustomizer implements JvppReplyConsumer, InitializingReaderCustomizer<IpsecState, IpsecStateBuilder>, Ipv4Translator,
Ipv6Translator { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final IpsecState readValue) { IpsecStateBuilder ipsecParentBuilder = (IpsecStateBuilder) parentBuilder; ipsecParentBuilder.setHoldDown(readValue.getHoldDown()) .setPolicy(readValue.getPolicy()) .setProposal(readValue.getProposal()) .setRedundancy(readValue.getRedundancy()) .setSa(readValue.getSa()) .addAugmentation(IpsecStateSpdAugmentation.class, readValue.augmentation(IpsecStateSpdAugmentation.class)); } IpsecStateCustomizer(final FutureJVppCore vppApi); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<IpsecState> id,
@Nonnull final IpsecState readValue, @Nonnull final ReadContext ctx); @Nonnull @Override IpsecStateBuilder getBuilder(@Nonnull final InstanceIdentifier<IpsecState> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<IpsecState> id,
@Nonnull final IpsecStateBuilder builder,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final IpsecState readValue); } | @Test public void testMerge() { final IpsecStateBuilder parentBuilder = new IpsecStateBuilder(); final IpsecStateBuilder builderForNewdata = new IpsecStateBuilder(); builderForNewdata.setHoldDown((long) HOLD_DOWN); getCustomizer().merge(parentBuilder, builderForNewdata.build()); assertEquals(parentBuilder.getHoldDown().intValue(), HOLD_DOWN); } |
IpsecStateSpdCustomizer extends FutureJVppCustomizer implements JvppReplyConsumer, InitializingListReaderCustomizer<Spd, SpdKey, SpdBuilder>, Ipv4Translator,
Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final SpdBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { SpdKey key = id.firstKeyOf(Spd.class); builder.withKey(key); builder.setSpdId(key.getSpdId()); Optional<IpsecSpdDetailsReplyDump> spdDump = ipsecSpdDetailsReplyDumpManager.getDump(id, ctx.getModificationCache()); if (spdDump.isPresent()) { List<SpdEntries> spdEntries = spdDump.get().ipsecSpdDetails.stream().map(details -> translateDetailToEntry(details)) .collect(Collectors.toList()); builder.setSpdEntries(spdEntries); } } IpsecStateSpdCustomizer(final FutureJVppCore vppApi); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Spd> id,
@Nonnull final Spd readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override SpdBuilder getBuilder(@Nonnull final InstanceIdentifier<Spd> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final SpdBuilder builder,
@Nonnull final ReadContext ctx); @Nonnull @Override List<SpdKey> getAllIds(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Spd> readData); } | @Test public void testReadSpd() throws ReadFailedException { final SpdBuilder builder = new SpdBuilder(); getCustomizer().readCurrentAttributes(SPD_IID, builder, ctx); assertEquals(builder.getSpdEntries().size(), 1); SpdEntries spdEntries = builder.getSpdEntries().get(0); assertEquals(spdEntries.getDirection().getName(), "outbound"); assertEquals(spdEntries.getPriority().intValue(), PRIORITY); } |
IpsecStateSpdCustomizer extends FutureJVppCustomizer implements JvppReplyConsumer, InitializingListReaderCustomizer<Spd, SpdKey, SpdBuilder>, Ipv4Translator,
Ipv6Translator { @Override public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Spd> readData) { ((IpsecStateSpdAugmentationBuilder) builder).setSpd(readData); } IpsecStateSpdCustomizer(final FutureJVppCore vppApi); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Spd> id,
@Nonnull final Spd readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override SpdBuilder getBuilder(@Nonnull final InstanceIdentifier<Spd> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final SpdBuilder builder,
@Nonnull final ReadContext ctx); @Nonnull @Override List<SpdKey> getAllIds(@Nonnull final InstanceIdentifier<Spd> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Spd> readData); } | @Test public void testMerge() throws Exception { final IpsecStateSpdAugmentationBuilder parentBuilder = new IpsecStateSpdAugmentationBuilder(); final IpsecStateSpdAugmentationBuilder builderForNewData = new IpsecStateSpdAugmentationBuilder(); SpdBuilder spdBuilder = new SpdBuilder(); spdBuilder.setSpdId(SPD_ID); getCustomizer().merge(parentBuilder, spdBuilder.build()); assertEquals(parentBuilder.getSpd().size(), 1); assertEquals(parentBuilder.getSpd().get(0).getSpdId().intValue(), SPD_ID); } |
DhcpRelayValidator implements Validator<Relay> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay relay, @Nonnull final WriteContext writeContext) throws CreateValidationFailedException { try { validateRelay(relay); } catch (RuntimeException e) { throw new CreateValidationFailedException(id, relay, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay relay,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay dataBefore,
@Nonnull final Relay dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testWrite(@InjectTestData(resourcePath = "/relay/ipv4DhcpRelay.json", id = RELAYS_PATH) Relays relays) throws DataValidationFailedException.CreateValidationFailedException { final int rxVrfId = 0; validator.validateWrite(getId(rxVrfId, Ipv4.class), extractRelay(relays), writeContext); } |
DhcpRelayValidator implements Validator<Relay> { @Override public void validateUpdate(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay dataBefore, @Nonnull final Relay dataAfter, @Nonnull final WriteContext writeContext) throws UpdateValidationFailedException { try { validateRelay(dataBefore); validateRelay(dataAfter); } catch (RuntimeException e) { throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay relay,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay dataBefore,
@Nonnull final Relay dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testUpdate( @InjectTestData(resourcePath = "/relay/ipv6DhcpRelayBefore.json", id = RELAYS_PATH) Relays relaysBefore, @InjectTestData(resourcePath = "/relay/ipv6DhcpRelayAfter.json", id = RELAYS_PATH) Relays relayAfter) throws DataValidationFailedException.UpdateValidationFailedException { final int rxVrfId = 1; validator.validateUpdate(getId(rxVrfId, Ipv6.class), extractRelay(relaysBefore), extractRelay(relayAfter), writeContext); } |
DhcpRelayValidator implements Validator<Relay> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay dataBefore, @Nonnull final WriteContext writeContext) throws DeleteValidationFailedException { try { validateRelay(dataBefore); } catch (RuntimeException e) { throw new DeleteValidationFailedException(id, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay relay,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Relay> id,
@Nonnull final Relay dataBefore,
@Nonnull final Relay dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Relay> id, @Nonnull final Relay dataBefore,
@Nonnull final WriteContext writeContext); } | @Test public void testDelete(@InjectTestData(resourcePath = "/relay/ipv4DhcpRelay.json", id = RELAYS_PATH) Relays relays) throws DataValidationFailedException.DeleteValidationFailedException { final int rxVrfId = 0; validator.validateDelete(getId(rxVrfId, Ipv4.class), extractRelay(relays), writeContext); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.