Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } private InitSubtreeReader(final InitReader<O, B> delegate, final Set<InstanceIdentifier<?>> handledTypes); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }
@Test public void testInit() throws Exception { final InitReader<DataObject1, Builder<DataObject1>> initSubReader = InitSubtreeReader.createForReader(Sets.newHashSet(DataObject1.DataObject11.IID), delegate); assertFalse(initSubReader instanceof ListReader); initSubReader.init(broker, DataObject1.IID, ctx); verify(delegate).init(broker, DataObject1.IID, ctx); }
CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType); @Override void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys); @Override ReaderRegistry build(); }
@Test(expected = IllegalArgumentException.class) public void testPreventStructuralReaderForList() { new CompositeReaderRegistryBuilder(new YangDAG()).addStructuralReader(InstanceIdentifier.create(DataObjects.DataObjectK.class), DataObjects.DataObjectKBuilder.class); }
CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public ReaderRegistry build() { ImmutableMap<InstanceIdentifier<?>, Reader<? extends DataObject, ? extends Builder<?>>> mappedReaders = getMappedHandlers(); LOG.debug("Building Reader registry with Readers: {}", mappedReaders.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building Reader registry with Readers: {}", mappedReaders); final List<InstanceIdentifier<?>> readerOrder = new ArrayList<>(mappedReaders.keySet()); final TypeHierarchy typeHierarchy = TypeHierarchy.create(mappedReaders.keySet()); final List<Reader<? extends DataObject, ? extends Builder<?>>> orderedRootReaders = typeHierarchy.getRoots().stream() .map(rootId -> toCompositeReader(rootId, mappedReaders, typeHierarchy)) .collect(Collectors.toList()); orderedRootReaders.sort( Comparator.comparingInt(reader -> readerOrder.indexOf(reader.getManagedDataObjectType()))); return new CompositeReaderRegistry(orderedRootReaders); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType); @Override void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys); @Override ReaderRegistry build(); }
@Test public void testCompositeStructure() throws Exception { final CompositeReaderRegistryBuilder compositeReaderRegistryBuilder = new CompositeReaderRegistryBuilder(new YangDAG()); compositeReaderRegistryBuilder.add(reader1); compositeReaderRegistryBuilder.addAfter(reader2, reader1.getManagedDataObjectType()); compositeReaderRegistryBuilder.addAfter(reader3, reader2.getManagedDataObjectType()); compositeReaderRegistryBuilder.addAfter(reader31, reader1.getManagedDataObjectType()); compositeReaderRegistryBuilder.addAfter(reader4, reader3.getManagedDataObjectType()); compositeReaderRegistryBuilder.add(reader41); compositeReaderRegistryBuilder.addBefore(reader42, reader41.getManagedDataObjectType()); compositeReaderRegistryBuilder.add(reader411); final ReaderRegistry build = compositeReaderRegistryBuilder.build(); final Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> rootReaders = ((CompositeReaderRegistry) build).getRootReaders(); final List<Class<? extends DataObject>> rootReaderOrder = Lists.newArrayList(rootReaders.keySet()); assertEquals(reader1.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(0)); assertEquals(reader2.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(1)); assertEquals(reader3.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(2)); assertEquals(reader4.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(3)); assertFalse(rootReaders.get(DataObjects.DataObject1.class) instanceof CompositeReader); assertFalse(rootReaders.get(DataObjects.DataObject2.class) instanceof CompositeReader); assertTrue(rootReaders.get(DataObjects.DataObject3.class) instanceof CompositeReader); assertTrue(rootReaders.get(DataObjects.DataObject4.class) instanceof CompositeReader); final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders = ((CompositeReader<? extends DataObject, ? extends Builder<?>>) rootReaders .get(DataObjects.DataObject4.class)).getChildReaders(); final List<Class<?>> orderedChildReaders = Lists.newArrayList(childReaders.keySet()); assertEquals(reader42.getManagedDataObjectType().getTargetType(), orderedChildReaders.get(0)); assertEquals(reader41.getManagedDataObjectType().getTargetType(), orderedChildReaders.get(1)); assertTrue(childReaders.get(DataObjects.DataObject4.DataObject41.class) instanceof CompositeReader); assertFalse(childReaders.get(DataObjects.DataObject4.DataObject42.class) instanceof CompositeReader); }
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) { try (ReadTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) { try { return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform read of " + currentId, e); } } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }
@Test public void testRead() { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFluentFuture(Optional.of((data))); when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(broker).newReadOnlyTransaction(); verify(readTx).read(LogicalDatastoreType.OPERATIONAL, id); when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)) .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); }
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, path, data); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform merge of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }
@Test public void testMerge() { ctx.merge(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, id, data); } @Test(expected = IllegalStateException.class) public void testMergeFailure() throws Exception { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.merge(id, data); }
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, path, data); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform put of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }
@Test public void testPut() { ctx.put(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, id, data); } @Test(expected = IllegalStateException.class) public void testPutFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.put(id, data); }
RealtimeMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.delete(LogicalDatastoreType.OPERATIONAL, path); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform delete of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }
@Test public void testDelete() { ctx.delete(id); verify(broker).newWriteOnlyTransaction(); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); } @Test(expected = IllegalStateException.class) public void testDeleteFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.delete(id); }
YangDAG { public void addVertex(final InstanceIdentifier<?> vertex) { dag.addVertex(vertex); } void addVertex(final InstanceIdentifier<?> vertex); void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target); Iterator<InstanceIdentifier<?>> iterator(); }
@Test public void testAddVertex() { dag.addVertex(VERTEX_A); final Iterator<InstanceIdentifier<?>> it = dag.iterator(); assertEquals(VERTEX_A, it.next()); assertFalse(it.hasNext()); }
YangDAG { public void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target) { try { dag.addDagEdge(source, target); } catch (DirectedAcyclicGraph.CycleFoundException e) { throw new IllegalArgumentException(String.format( "Unable to add writer with relation: %s -> %s. Loop detected", source, target), e); } } void addVertex(final InstanceIdentifier<?> vertex); void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target); Iterator<InstanceIdentifier<?>> iterator(); }
@Test public void testAddEdge() { dag.addVertex(VERTEX_A); dag.addVertex(VERTEX_B); dag.addEdge(VERTEX_A, VERTEX_B); final Iterator<InstanceIdentifier<?>> it = dag.iterator(); assertEquals(VERTEX_A, it.next()); assertEquals(VERTEX_B, it.next()); assertFalse(it.hasNext()); }
BindingBrokerWriter implements Writer<D> { @Override public void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter); final FluentFuture<? extends CommitInfo> result = writeTransaction.commit(); try { result.get(); } catch (InterruptedException | ExecutionException ex) { throw new WriteFailedException(id, ex); } } BindingBrokerWriter(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); @Override void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); }
@Test(expected = io.fd.honeycomb.translate.write.WriteFailedException.class) public void testFailedWrite() throws Exception { when(tx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(new InterruptedException("failing"))); bbWriter.processModification(id, data, data, ctx); }
JsonUtils { public static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData, @Nonnull final SchemaContext schemaContext, @Nonnull final OutputStream outputStream) throws IOException { final JsonWriter jsonWriter = createJsonWriter(outputStream, true); final NormalizedNodeStreamWriter streamWriter = JSONNormalizedNodeStreamWriter .createNestedWriter(JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), SchemaPath.ROOT, null, jsonWriter); final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(streamWriter, true); jsonWriter.beginObject(); writeChildren(normalizedNodeWriter,(ContainerNode) rootData); jsonWriter.endObject(); jsonWriter.flush(); normalizedNodeWriter.close(); jsonWriter.close(); } private JsonUtils(); static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData, @Nonnull final SchemaContext schemaContext, @Nonnull final OutputStream outputStream); static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream); static ContainerNode readJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema); static ContainerNode readContainerEntryJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema, @Nonnull final YangInstanceIdentifier.NodeIdentifier nodeIdentifier); static MapEntryNode readListEntryFromJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema, @Nonnull final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier); }
@Test public void testPersist() throws Exception { NormalizedNode<?, ?> data = getData("testing"); JsonUtils.writeJsonRoot(data, schemaContext, Files.newOutputStream(tmpPersistFile, StandardOpenOption.CREATE)); assertTrue(Files.exists(tmpPersistFile)); String persisted = new String(Files.readAllBytes(tmpPersistFile)); String expected = new String(ByteStreams.toByteArray(getClass().getResourceAsStream("/expected-persisted-output.txt"))); assertEquals(expected, persisted); data = getData("testing2"); JsonUtils.writeJsonRoot(data, schemaContext, Files.newOutputStream(tmpPersistFile, StandardOpenOption.CREATE)); persisted = new String(Files.readAllBytes(tmpPersistFile)); assertEquals(expected.replace("testing", "testing2"), persisted); assertTrue(Files.exists(tmpPersistFile)); }
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } private JsonUtils(); static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData, @Nonnull final SchemaContext schemaContext, @Nonnull final OutputStream outputStream); static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream); static ContainerNode readJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema); static ContainerNode readContainerEntryJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema, @Nonnull final YangInstanceIdentifier.NodeIdentifier nodeIdentifier); static MapEntryNode readListEntryFromJson(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream, @Nonnull final SchemaNode parentSchema, @Nonnull final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier); }
@Test public void testRestore() throws Exception { final ContainerNode normalizedNodeOptional = JsonUtils .readJsonRoot(schemaContext, getClass().getResourceAsStream("/expected-persisted-output.txt")); assertEquals(getData("testing"), normalizedNodeOptional); } @Test(expected = IllegalArgumentException.class) public void testRestoreInvalidFile() throws Exception { JsonUtils.readJsonRoot(schemaContext, getClass().getResourceAsStream("/test-persistence.yang")); }
KeepaliveReaderWrapper implements DelegatingReader<D, B>,Runnable, Closeable { @Override public void close() { scheduledFuture.cancel(false); } KeepaliveReaderWrapper(@Nonnull final Reader<D, B> delegate, @Nonnull final ScheduledExecutorService executor, @Nonnull final Class<? extends Exception> exception, @Nonnegative final int delayInSeconds, @Nonnull final KeepaliveFailureListener failureListener); @Override void run(); @Override void close(); @Override Reader<D, B> getDelegate(); }
@Test(timeout = 10000) public void testKeepalive() throws Exception { final CapturingFailListener listener = new CapturingFailListener(); final KeepaliveReaderWrapper<DataObject, Builder<DataObject>> keepaliveWrapper = new KeepaliveReaderWrapper<>(delegate, exec, TestingException.class, 1, listener); keepaliveWrapper.readCurrentAttributes(id, builder, ctx); verify(delegate).readCurrentAttributes(id, builder, ctx); keepaliveWrapper.getBuilder(id); verify(delegate).getBuilder(id); assertTrue(listener.getTriggerFuture().get()); verify(delegate).read(any(InstanceIdentifier.class), any(ReadContext.class)); keepaliveWrapper.close(); } @Test(timeout = 10000) public void testKeepaliveCancel() throws Exception { final CapturingFailListener listener = new CapturingFailListener(); final KeepaliveReaderWrapper<DataObject, Builder<DataObject>> keepaliveWrapper = new KeepaliveReaderWrapper<>(delegate, exec, TestingException.class, 100000, listener); keepaliveWrapper.close(); assertFalse(listener.getTriggerFuture().isDone()); }
TypeAwareIdentifierCacheKeyFactory implements CacheKeyFactory<U> { @Override public String createKey(@Nonnull final InstanceIdentifier<?> actualContextIdentifier, @Nullable final U dumpParams) { checkNotNull(actualContextIdentifier, "Cannot construct key for null InstanceIdentifier"); if (additionalKeyTypes.isEmpty()) { return String .join(KEY_PARTS_SEPARATOR, type.getTypeName(), params(dumpParams), actualContextIdentifier.getTargetType().toString()); } checkArgument(isUniqueKeyConstructable(actualContextIdentifier), "Unable to construct unique key, required key types : %s, provided paths : %s", additionalKeyTypes, actualContextIdentifier.getPathArguments()); return String .join(KEY_PARTS_SEPARATOR, type.getTypeName(), additionalKeys(actualContextIdentifier), params(dumpParams), actualContextIdentifier.getTargetType().toString()); } TypeAwareIdentifierCacheKeyFactory(@Nonnull final Class<?> type); TypeAwareIdentifierCacheKeyFactory(@Nonnull final Class<?> type, @Nonnull final Set<Class<? extends DataObject>> additionalKeyTypes); @Override String createKey(@Nonnull final InstanceIdentifier<?> actualContextIdentifier, @Nullable final U dumpParams); @Override Class<?> getCachedDataType(); }
@Test public void createKeyBothKeyedComplex() { final String key = complexKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifyComplexKey(key, NO_PARAMS_KEY); } @Test public void createKeyBothKeyedComplexWithParams() { final String key = complexIntegerKeyFactory.createKey(identifierBothKeyed, 123); verifyComplexKey(key, "123"); } @Test(expected = IllegalArgumentException.class) public void createKeyOneMissingComplex() { complexKeyFactory.createKey(identifierOneMissing, NO_PARAMS); } @Test(expected = IllegalArgumentException.class) public void createKeyNoneKeyedComplex() { complexKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); } @Test public void createKeyBothKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifySimpleKey(key); } @Test public void createKeyOneMissingSimple() { final String key = simpleKeyFactory.createKey(identifierOneMissing, NO_PARAMS); verifySimpleKey(key); } @Test public void createKeyNoneKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); verifySimpleKey(key); }
DataObjectUpdate { private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter) { this.id = checkNotNull(id); this.dataAfter = dataAfter; this.dataBefore = dataBefore; } private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter); DataObject getDataBefore(); DataObject getDataAfter(); InstanceIdentifier<?> getId(); static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); DataObjectUpdate reverse(); }
@Test public void testDataObjectUpdate() throws Exception { final DataObjectUpdate dataObjectUpdate = DataObjectUpdate.create(id, first, second); assertEquals(id, dataObjectUpdate.getId()); assertEquals(first, dataObjectUpdate.getDataBefore()); assertEquals(second, dataObjectUpdate.getDataAfter()); final DataObjectUpdate reverse = dataObjectUpdate.reverse(); assertEquals(dataObjectUpdate, reverse); assertEquals(dataObjectUpdate.hashCode(), reverse.hashCode()); assertEquals(dataObjectUpdate, reverse.reverse()); }
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } private DumpCacheManager(DumpCacheManagerBuilder<T, U> builder); Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache); Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache, final U dumpParams); }
@Test public void testCaching() throws ReadFailedException { final IpDetailsReplyDump stage1Data = new IpDetailsReplyDump(); final String key = cacheKeyFactory.createKey(identifier, NO_PARAMS); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(new IpDetailsReplyDump()); final Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(identifier, cache); assertEquals(true, stage1Optional.isPresent()); assertEquals(stage1Data, stage1Optional.get()); assertEquals(true, cache.containsKey(key)); assertEquals(stage1Data, cache.get(key)); IpDetailsReplyDump stage2LoadedDump = new IpDetailsReplyDump(); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(stage2LoadedDump); final Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(identifier, cache); assertEquals(true, stage2Optional.isPresent()); assertEquals(stage2LoadedDump, stage2Optional.get()); IpDetailsReplyDump stage3LoadedDump = new IpDetailsReplyDump(); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(stage3LoadedDump); final Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(identifier, cache); assertEquals(true, stage3Optional.isPresent()); assertEquals(stage2LoadedDump, stage3Optional.get()); } @Test public void testPostprocessing() throws ReadFailedException { IpDetailsReplyDump dump = new IpDetailsReplyDump(); IpDetails details = new IpDetails(); details.swIfIndex = 2; dump.ipDetails.add(details); when(executor.executeDump(identifier, null)).thenReturn(dump); Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(identifier, cache); assertEquals(true, optionalDump.isPresent()); assertEquals(1, optionalDump.get().ipDetails.size()); assertEquals(7, optionalDump.get().ipDetails.get(0).swIfIndex); } @Test public void testSameKeyDifferentTypes() throws ReadFailedException { final DumpCacheManager<String, Void> stringManager = new DumpCacheManager.DumpCacheManagerBuilder<String, Void>() .withExecutor((InstanceIdentifier, Void) -> "value") .acceptOnly(String.class) .build(); final DumpCacheManager<Integer, Void> intManager = new DumpCacheManager.DumpCacheManagerBuilder<Integer, Void>() .acceptOnly(Integer.class) .withExecutor((InstanceIdentifier, Void) -> 3).build(); final Optional<String> stringDump = stringManager.getDump(identifier, cache); final Optional<Integer> integerDump = intManager.getDump(identifier, cache); assertTrue(stringDump.isPresent()); assertTrue(integerDump.isPresent()); assertEquals("value", stringDump.get()); assertEquals(3, integerDump.get().intValue()); } @Test public void testCachingWithDifferentParams() throws ReadFailedException { final DumpCacheManager<Integer, Integer> manager = new DumpCacheManager.DumpCacheManagerBuilder<Integer, Integer>() .withExecutor((iid, param) -> param) .acceptOnly(Integer.class) .build(); final Optional<Integer> dump1 = manager.getDump(identifier, cache, 1); final Optional<Integer> dump2 = manager.getDump(identifier, cache, 2); assertEquals(1, dump1.get().intValue()); assertEquals(2, dump2.get().intValue()); }
ReflexiveListReaderCustomizer extends ReflexiveReaderCustomizer<C, B> implements ListReaderCustomizer<C, K, B> { @Override public void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context) throws ReadFailedException { final Optional<Method> method = ReflectionUtils.findMethodReflex(builder.getClass(), "withKey", Collections.singletonList(keyType), builder.getClass()); checkArgument(method.isPresent(), "Unable to build withKey for %s", builder); try { method.get().invoke(builder, ((KeyedInstanceIdentifier)id).getKey()); } catch (IllegalAccessException | InvocationTargetException e) { throw new IllegalArgumentException("Unable to build withKey for " + builder, e); } } ReflexiveListReaderCustomizer(@Nonnull final Class<C> typeClass, @Nonnull final Class<B> builderClass, @Nonnull final List<K> staticKeys); @Override void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final List<C> readData); @Nonnull @Override List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context); }
@Test @SuppressWarnings("unchecked") public void testReadCurrentAttributes() throws ReadFailedException { final TestingListObject.TestingListKey keyOne = new TestingListObject.TestingListKey("1"); final TestingListObject.TestingListKey keyTwo = new TestingListObject.TestingListKey("2"); final List<TestingListObject.TestingListKey> staticKeys = Arrays.asList(keyOne, keyTwo); final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListObjectBuilder> customizer = new ReflexiveListReaderCustomizer<>(TestingListObject.class, TestingListObjectBuilder.class, staticKeys); final TestingListObjectBuilder builder = new TestingListObjectBuilder(); final InstanceIdentifier<TestingListObject> id = (InstanceIdentifier<TestingListObject>) InstanceIdentifier.create( Collections.singletonList(InstanceIdentifier.IdentifiableItem.of(TestingListObject.class, keyOne))); customizer.readCurrentAttributes(id, builder, readContext); assertEquals(keyOne, builder.getKey()); }
ReflexiveListReaderCustomizer extends ReflexiveReaderCustomizer<C, B> implements ListReaderCustomizer<C, K, B> { @Nonnull @Override public List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context) throws ReadFailedException { return staticKeys; } ReflexiveListReaderCustomizer(@Nonnull final Class<C> typeClass, @Nonnull final Class<B> builderClass, @Nonnull final List<K> staticKeys); @Override void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final List<C> readData); @Nonnull @Override List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context); }
@Test public void testGetAllIds() throws ReadFailedException { final TestingListObject.TestingListKey keyOne = new TestingListObject.TestingListKey("1"); final TestingListObject.TestingListKey keyTwo = new TestingListObject.TestingListKey("2"); final List<TestingListObject.TestingListKey> staticKeys = Arrays.asList(keyOne, keyTwo); final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListObjectBuilder> customizer = new ReflexiveListReaderCustomizer<>(TestingListObject.class, TestingListObjectBuilder.class, staticKeys); final List<TestingListObject.TestingListKey> allIds = customizer.getAllIds(InstanceIdentifier.create(TestingListObject.class), readContext); assertThat(allIds, hasSize(2)); assertThat(allIds, contains(keyOne, keyTwo)); }
BindingBrokerReader implements Reader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { try (final ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) { final FluentFuture<? extends Optional<? extends DataObject>> read = readOnlyTransaction.read(datastoreType, id); try { return read.get(); } catch (InterruptedException | ExecutionException ex) { throw new ReadFailedException(id, ex); } } } BindingBrokerReader(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker, final LogicalDatastoreType datastoreType, final Class<B> builderClass); @Override boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue); @Nonnull @Override B getBuilder(final InstanceIdentifier<D> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); }
@Test public void testRead() throws Exception { assertEquals(id, bbReader.getManagedDataObjectType()); assertNotNull(bbReader.getBuilder(id)); final Optional<? extends DataObject> read = bbReader.read(id, ctx); assertSame(data, read.get()); verify(broker).newReadOnlyTransaction(); } @Test(expected = io.fd.honeycomb.translate.read.ReadFailedException.class) public void testFailedRead() throws Exception { when(tx.read(LogicalDatastoreType.CONFIGURATION, id)) .thenReturn(FluentFutures.immediateFailedFluentFuture(new ReadFailedException("failing"))); bbReader.read(id, ctx); }
DataObjectUpdate { public static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter) { checkArgument(!(dataBefore == null && dataAfter == null), "Both before and after data are null"); if (dataBefore != null) { checkArgument(id.getTargetType().isAssignableFrom(dataBefore.getClass())); } if (dataAfter != null) { checkArgument(id.getTargetType().isAssignableFrom(dataAfter.getClass())); } return dataAfter == null ? new DataObjectDelete(id, dataBefore) : new DataObjectUpdate(id, dataBefore, dataAfter); } private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter); DataObject getDataBefore(); DataObject getDataAfter(); InstanceIdentifier<?> getId(); static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); DataObjectUpdate reverse(); }
@Test public void testDataObjectDelete() throws Exception { final DataObjectUpdate dataObjectUpdate = DataObjectUpdate.create(id, first, null); assertTrue(DataObjectUpdate.DataObjectDelete.class.isAssignableFrom(dataObjectUpdate.getClass())); }
BindingBrokerReader implements Reader<D, B> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx) throws ReadFailedException { throw new UnsupportedOperationException("Not supported"); } BindingBrokerReader(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker, final LogicalDatastoreType datastoreType, final Class<B> builderClass); @Override boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue); @Nonnull @Override B getBuilder(final InstanceIdentifier<D> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); }
@Test(expected = UnsupportedOperationException.class) public void testReadCurrentAttrs() throws Exception { bbReader.readCurrentAttributes(id, new DataObjectBuilder(), ctx); }
ReflexiveReaderCustomizer extends NoopReaderCustomizer<C, B> { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue) { if (Augmentation.class.isAssignableFrom(typeClass)) { mergeAugmentation(parentBuilder, (Class<? extends Augmentation<?>>) typeClass, readValue); } else { mergeRegular(parentBuilder, readValue); } } ReflexiveReaderCustomizer(final Class<C> typeClass, final Class<B> builderClass); @Nonnull @Override B getBuilder(@Nonnull InstanceIdentifier<C> id); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); }
@Test public void testReflexCustomizerAugment() throws Exception { final ReflexiveReaderCustomizer<TestingAugmentation, TestingAugmentBuilder> reflexReaderCustomizer = new ReflexiveReaderCustomizer<>(TestingAugmentation.class, TestingAugmentBuilder.class); final TestingBuilderParent parentBuilder = new TestingBuilderParent(); final TestingAugmentation readValue = new TestingAugmentation(); reflexReaderCustomizer.merge(parentBuilder, readValue); assertEquals(readValue, parentBuilder.getAugmentation()); } @Test public void testReflexCustomizerList() throws Exception { final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListBuilder> reflexReaderCustomizer = new ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListBuilder> (TestingListObject.class, TestingListBuilder.class, Collections.singletonList(new TestingListObject.TestingListKey())); final TestingBuilderParent parentBuilder = new TestingBuilderParent(); final List<TestingListObject> readValue = Lists.newArrayList(new TestingListObject(), new TestingListObject()); reflexReaderCustomizer.merge(parentBuilder, readValue); assertEquals(readValue, parentBuilder.getTestingListObject()); final TestingListObject single = new TestingListObject(); reflexReaderCustomizer.merge(parentBuilder, single); assertEquals(Collections.singletonList(single), parentBuilder.getTestingListObject()); }
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) { try { return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); } catch (InterruptedException | ExecutionException ex) { throw new IllegalStateException("Unable to perform read", ex); } } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }
@Test public void testRead() throws Exception { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFluentFuture(Optional.of((data))); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(writeTx).read(LogicalDatastoreType.OPERATIONAL, id); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)) .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); } @Test(expected = IllegalStateException.class) public void testReadFailure() throws Exception { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFailedFluentFuture(ex); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); }
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, T data) { readWriteTransaction.merge(LogicalDatastoreType.OPERATIONAL, path, data, true); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }
@Test public void testMerge() throws Exception { ctx.merge(id, data); verify(writeTx).merge(LogicalDatastoreType.OPERATIONAL, id, data, true); }
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> void put(final InstanceIdentifier<T> path, T data) { readWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, path, data, true); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }
@Test public void testPut() throws Exception { ctx.put(id, data); verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, id, data, true); }
TransactionMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { readWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, path); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }
@Test public void testDelete() throws Exception { ctx.delete(id); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); }
TransactionMappingContext implements MappingContext { @Override public void close() { readWriteTransaction.cancel(); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }
@Test public void testClose() throws Exception { ctx.close(); verify(writeTx).cancel(); }
ModificationCache implements AutoCloseable { public Object get(final Object o) { return map.get(o); } ModificationCache(); Object get(final Object o); boolean containsKey(final Object o); Object put(final Object o, final Object o2); @Override void close(); }
@Test public void get() throws Exception { final Object o = new Object(); assertNull(cache.get(o)); assertFalse(cache.containsKey(o)); assertNull(cache.put(o, o)); assertTrue(cache.containsKey(o)); assertEquals(o, cache.get(o)); assertEquals(o, cache.put(o, o)); cache.close(); assertFalse(cache.containsKey(o)); }
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String protocolName = dataAfter.getName(); checkArgument(protocolInstanceName.equals(protocolName), "Only single protocol named %s is supported, but %s was given", protocolInstanceName, protocolName); final Class<? extends InstallProtocolType> identifier = dataAfter.getIdentifier(); checkArgument(BGP.class.equals(identifier), "Only BGP protocol type is supported, but %s was given", identifier); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).setIdentifier(BGP.class).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); } @Test(expected = IllegalArgumentException.class) public void testWriteInvalidProtocolName() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName("some-other-name").setIdentifier(BGP.class).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); } @Test(expected = IllegalArgumentException.class) public void testWriteInvalidProtocolType() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); }
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, new UnsupportedOperationException("Network instance protocol update is not supported")); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(Protocol.class), mock(Protocol.class), ctx); }
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Network instance protocol delete is not supported")); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(Protocol.class), ctx); }
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String instanceName = dataAfter.getName(); checkArgument(networkInstanceName.equals(instanceName), "Only single network instance named %s is supported, but %s was given", networkInstanceName, instanceName); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); } @Test(expected = IllegalArgumentException.class) public void testWriteInvalidInstanceName() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName("some-other-name").build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); }
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, new UnsupportedOperationException("Network instance update is not supported")); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(NetworkInstance.class), mock(NetworkInstance.class), ctx); }
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Network instance delete is not supported")); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(NetworkInstance.class), ctx); }
NotificationProducerTracker implements DOMNotificationSubscriptionListener, AutoCloseable { @Override public synchronized void onSubscriptionChanged(final Set<SchemaPath> set) { LOG.debug("Subscriptions changed. Current subscriptions: {}", set); final Set<QName> currentSubscriptions = set.stream().map(SchemaPath::getLastComponent).collect(Collectors.toSet()); final Set<QName> startedQNames = getStartedQNames(alreadyStartedProducers); final Sets.SetView<QName> newSubscriptions = Sets.difference(currentSubscriptions, startedQNames); LOG.debug("Subscriptions changed. New subscriptions: {}", newSubscriptions); final Sets.SetView<QName> deletedSubscriptions = Sets.difference(startedQNames, currentSubscriptions); LOG.debug("Subscriptions changed. Deleted subscriptions: {}", deletedSubscriptions); newSubscriptions.stream().forEach(newSub -> { if(!registry.getNotificationQNameToProducer().containsKey(newSub)) { return; } final ManagedNotificationProducer producer = registry.getNotificationQNameToProducer().get(newSub); if(alreadyStartedProducers.contains(producer)) { return; } LOG.debug("Starting notification producer: {}", producer); producer.start(collector); alreadyStartedProducers.add(producer); }); deletedSubscriptions.stream().forEach(newSub -> { checkState(registry.getNotificationQNameToProducer().containsKey(newSub)); final ManagedNotificationProducer producer = registry.getNotificationQNameToProducer().get(newSub); checkState(alreadyStartedProducers.contains(producer)); LOG.debug("Stopping notification producer: {}", producer); producer.stop(); alreadyStartedProducers.remove(producer); }); } NotificationProducerTracker(@Nonnull final NotificationProducerRegistry registry, @Nonnull final NotificationCollector collector, @Nonnull final DOMNotificationSubscriptionListenerRegistry notificationRouter); @Override synchronized void onSubscriptionChanged(final Set<SchemaPath> set); @Override synchronized void close(); }
@Test public void name() throws Exception { final NotificationProducerTracker notificationProducerTracker = new NotificationProducerTracker(registry, collector, subscriptionRegistry); verify(subscriptionRegistry).registerSubscriptionListener(notificationProducerTracker); final Set<SchemaPath> subscriptions = Sets.newHashSet(); subscriptions.add(SchemaPath.create(true, NetconfSessionStart.QNAME)); notificationProducerTracker.onSubscriptionChanged(subscriptions); verify(producer).start(collector); notificationProducerTracker.onSubscriptionChanged(Sets.newHashSet()); verify(producer).stop(); }
FibTableCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Table, TableKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext) throws WriteFailedException { bindFibTableRequest(table).write(instanceIdentifier); } FibTableCustomizer(@Nonnull final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext); }
@Test public void testWriteSimple(@InjectTestData(resourcePath = "/fib.json", id = FIB_PATH) FibTables tables) throws WriteFailedException { TableKey key = new TableKey(Ipv4.class, new VniReference(0L)); Table data = tables.getTable().stream().filter(table -> table.key().equals(key)).findAny().get(); customizer.writeCurrentAttributes(FibManagementIIds.FM_FIB_TABLES .child(Table.class, key), data, writeContext); final IpTableAddDel request = new IpTableAddDel(); request.isAdd = 1; request.isIpv6 = 0; request.tableId = 0; request.name = IPV4_VRF_0.getBytes(); verify(api).ipTableAddDel(request); }
LocatorContextManagerImpl implements LocatorContextManager { @Override public void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx) { final KeyedInstanceIdentifier<Srv6LocatorMapping, Srv6LocatorMappingKey> mappingIid = getLocatorIid(name); final Srv6LocatorMappingBuilder builder = new Srv6LocatorMappingBuilder() .withKey(new Srv6LocatorMappingKey(name)).setPrefix(ipv6Prefix).setName(name); ctx.put(mappingIid, builder.build()); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }
@Test public void addLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); contextManager.addLocator(LOCATOR.getName(), LOCATOR_PREFIX, ctx.getMappingContext()); verify(mappingContext, times(1)).put(any(), locMappingCaptor.capture()); Srv6LocatorMapping mapping = locMappingCaptor.getValue(); Assert.assertEquals(mapping.getPrefix(), LOCATOR_PREFIX); Assert.assertEquals(mapping.getName(), LOCATOR.getName()); }
LocatorContextManagerImpl implements LocatorContextManager { @Override public boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name)); return read.isPresent(); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }
@Test public void containsLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); boolean containsLocator = contextManager.containsLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertTrue(containsLocator); }
LocatorContextManagerImpl implements LocatorContextManager { @Override public Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name)); if (read.isPresent()) { return read.get().getPrefix(); } Ipv6Prefix ipv6Prefix = new Ipv6Prefix(getArtificialName(name)); addLocator(getArtificialName(name), ipv6Prefix, ctx); return ipv6Prefix; } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }
@Test public void getLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); Ipv6Prefix locator = contextManager.getLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertEquals(LOCATOR_PREFIX, locator); }
LocatorContextManagerImpl implements LocatorContextManager { @Override public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getLocatorIid(name)); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }
@Test public void removeLocatorTest() { MappingContext mappingContext = ctx.getMappingContext(); LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); contextManager.removeLocator(LOCATOR.getName(), mappingContext); verify(mappingContext, times(1)).delete(iidCaptor.capture()); Assert.assertEquals(LOCATOR.getName(), iidCaptor.getValue().firstKeyOf(Srv6LocatorMapping.class).getName()); }
EncapsulationSourceCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Encapsulation> { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceWriteRequest(encapsulation).write(instanceIdentifier); } EncapsulationSourceCustomizer(@Nonnull FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); }
@Test public void writeCurrentAttributesTest() throws WriteFailedException { sourceCustomizer.writeCurrentAttributes(Srv6IIds.RT_SRV6_ENCAP, encapsulation, ctx); verify(api, Mockito.times(1)).srSetEncapSource(requestCaptor.capture()); Assert.assertTrue(Arrays.equals(BSID_BYTES, requestCaptor.getValue().encapsSource)); }
EncapsulationSourceCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Encapsulation> { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceDeleteRequest().delete(instanceIdentifier); } EncapsulationSourceCustomizer(@Nonnull FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); }
@Test public void deleteCurrentAttributesTest() throws WriteFailedException { sourceCustomizer.deleteCurrentAttributes(Srv6IIds.RT_SRV6_ENCAP, encapsulation, ctx); verify(api, Mockito.times(1)).srSetEncapSource(requestCaptor.capture()); Assert.assertNull(requestCaptor.getValue().encapsSource); }
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext) throws WriteFailedException { InstanceIdentifier<Locator> locatorIid = RWUtils.cutId(instanceIdentifier, Locator.class); Optional<Locator> locatorOpt = writeContext.readAfter(locatorIid); Table vrfTable = getVrfTable(instanceIdentifier, writeContext, locatorIid, locatorOpt); LocalSidFunctionRequest request = bindRequest(extractLocPrefix(instanceIdentifier, locatorOpt, localSid), localSid, vrfTable.getTableId().getValue().intValue(), writeContext); request.write(instanceIdentifier); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }
@Test(expected = NullPointerException.class) public void writeCurrentAttributesNullTest() throws WriteFailedException { SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Sid localSid = getSidNull(); customizer.writeCurrentAttributes(SID_A_101, localSid, ctx); verify(api, times(0)).srLocalsidAddDel(any()); }
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext) throws WriteFailedException { InstanceIdentifier<Locator> locatorIid = RWUtils.cutId(instanceIdentifier, Locator.class); Optional<Locator> locatorOpt = writeContext.readBefore(locatorIid); Table vrfTable = getVrfTable(instanceIdentifier, writeContext, locatorIid, locatorOpt); LocalSidFunctionRequest request = bindRequest(extractLocPrefix(instanceIdentifier, locatorOpt, localSid), localSid, vrfTable.getTableId().getValue().intValue(), writeContext); request.delete(instanceIdentifier); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }
@Test(expected = NullPointerException.class) public void deleteCurrentAttributesNullTest() throws WriteFailedException { SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Sid localSid = getSidNull(); customizer.deleteCurrentAttributes(SID_A_101, localSid, ctx); verify(api, times(0)).srLocalsidAddDel(any()); }
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { Ipv6Address resolveSidAddress(@Nonnull final Prefix locPrefix, @Nonnull Sid localSid) { com.googlecode.ipv6.IPv6Address ip = com.googlecode.ipv6.IPv6Address.fromString(locPrefix.getAddress().getValue()); IPv6NetworkMask mask = IPv6NetworkMask.fromPrefixLength(locPrefix.getLength().getValue()); ip = ip.maskWithNetworkMask(mask); String locIp = ip.add(localSid.getOpcode().getValue().intValue()).toString(); return new Ipv6Address(locIp); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }
@Test public void resolveSidAddressTest() { Sid localSid = getSidNull(); SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Prefix locPrefix = new PrefixBuilder().setAddress(new Ipv6Address("a::")).setLength(new Srv6LocatorLen( (short) 64)).build(); Ipv6Address ipv6Address = customizer.resolveSidAddress(locPrefix, localSid); assertTrue((IP_ADDRESS.equals(ipv6Address))); }
Srv6Customizer implements WriterCustomizer<Srv6> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Writing SRV6 configuration is not supported by VPP. SRV6 is always enabled"); throw new WriteFailedException.CreateFailedException(instanceIdentifier, srv6, new UnsupportedOperationException("Changing SRV6 configuration is not supported by VPP.")); } @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void writeCurrentAttributesNullTest() throws WriteFailedException { Srv6Customizer customizer = new Srv6Customizer(); Srv6 srv6 = new Srv6Builder().setEnable(true).build(); customizer.writeCurrentAttributes(Srv6IIds.RT_SRV6, srv6, ctx); }
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey>, JvppReplyConsumer, ByteDataTranslator, Ipv6Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Updating Prefix {} before={} after={}", id, dataBefore, dataAfter); setPrefix(id, dataAfter, writeContext, false); } PrefixCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate(@InjectTestData(resourcePath = "/ra/complexPrefix.json", id = RA_PATH) PrefixList prefixList) throws WriteFailedException { final Prefix data = getPrefix(prefixList); customizer.updateCurrentAttributes(IID, mock(Prefix.class), data, writeContext); final SwInterfaceIp6NdRaPrefix request = new SwInterfaceIp6NdRaPrefix(); request.swIfIndex = IFC_INDEX; request.prefix = getPrefix( new byte[]{0x20, 0x01, 0x0d, (byte) 0xb8, 0x0a, 0x0b, 0x12, (byte) 0xf0, 0, 0, 0, 0, 0, 0, 0, 0x02}, (byte) 64); request.noAdvertise = 1; request.noAutoconfig = 1; request.valLifetime = -1; request.prefLifetime = 604800; verify(api).swInterfaceIp6NdRaPrefix(request); }
Srv6Customizer implements WriterCustomizer<Srv6> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Deleting SRV6 configuration is not supported by VPP. SRV6 is always enabled"); throw new WriteFailedException.DeleteFailedException(instanceIdentifier, new UnsupportedOperationException("Changing SRV6 configuration is not supported by VPP.")); } @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void deleteCurrentAttributesNullTest() throws WriteFailedException { Srv6Customizer customizer = new Srv6Customizer(); Srv6 srv6 = new Srv6Builder().setEnable(true).build(); customizer.deleteCurrentAttributes(Srv6IIds.RT_SRV6, srv6, ctx); }
PolicyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Policy, PolicyKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { VppSrPolicyAugmentation policyAugmentation = policy.augmentation(VppSrPolicyAugmentation.class); if (policyAugmentation != null && policyAugmentation.getVppSrPolicy() != null && policyAugmentation.getVppSrPolicy().getConfig() != null) { Config config = policyAugmentation.getVppSrPolicy().getConfig(); TableKey tableKey = new TableKey(config.getAddressFamily(), new VniReference(config.getTableId())); KeyedInstanceIdentifier<Table, TableKey> vrfIid = FibManagementIIds.FM_FIB_TABLES.child(Table.class, tableKey); if (!writeContext.readAfter(vrfIid).isPresent()) { throw new IllegalArgumentException( String.format("VRF table: %s not found. Create table before writing policy.", tableKey)); } if (policy.getCandidatePaths() != null && !policy.getCandidatePaths().getCandidatePath().isEmpty()) { bindWriteRequest(config, policy.getCandidatePaths().getCandidatePath(), writeContext) .write(instanceIdentifier); Ipv6Address bsid = Srv6Util.extractBsid(instanceIdentifier, writeContext, true); policyContext.addPolicy(policy.getName(), policy.getColor(), policy.getEndpoint().getIpv6Address(), bsid, writeContext.getMappingContext()); } } else { throw new ReadFailedException(instanceIdentifier, new Throwable("VppSrPolicyAugmentation and/or VppSrPolicy missing.")); } } catch (ReadFailedException e) { throw new WriteFailedException.CreateFailedException(instanceIdentifier, policy, e); } } PolicyCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final PolicyContextManager policyContext, @Nonnull final CandidatePathContextManager candidateContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext); }
@Test public void writeCurrentAttributesTest() throws WriteFailedException { PolicyCustomizer customizer = new PolicyCustomizer(api, policyCtx, candidatePathCtx); customizer.writeCurrentAttributes(Srv6PolicyIIds.SR_TE_PLS.child(Policy.class, POLICY_KEY), policies.getPolicy().get(0), ctx); verify(api, times(1)).srPolicyAdd(requestcaptorAdd.capture()); SrPolicyAdd srPolicy = requestcaptorAdd.getValue(); verify(api, times(1)).srPolicyMod(requestcaptorMod.capture()); SrPolicyMod srPolicyMod = requestcaptorMod.getValue(); Assert.assertEquals(0L, srPolicy.fibTable); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(BSID_ADR)), srPolicy.bsidAddr); Assert.assertEquals(ByteDataTranslator.BYTE_TRUE, srPolicy.isEncap); Assert.assertEquals(0, srPolicy.type); Assert.assertNotNull(srPolicy.sids); Assert.assertEquals(3, srPolicy.sids.numSids); Assert.assertEquals(0, srPolicy.sids.weight); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(B_ADDR)), srPolicy.sids.sids[0].addr); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(C_ADDR)), srPolicy.sids.sids[1].addr); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(A_ADDR)), srPolicy.sids.sids[2].addr); Assert.assertEquals(0L, srPolicyMod.fibTable); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(BSID_ADR)), srPolicyMod.bsidAddr); Assert.assertNotNull(srPolicy.sids); Assert.assertEquals(3, srPolicyMod.sids.numSids); Assert.assertEquals(1, srPolicyMod.sids.weight); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(C_ADDR)), srPolicyMod.sids.sids[0].addr); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(B_ADDR)), srPolicyMod.sids.sids[1].addr); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(A_ADDR)), srPolicyMod.sids.sids[2].addr); }
PolicyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Policy, PolicyKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (policy.getCandidatePaths() != null && !policy.getCandidatePaths().getCandidatePath().isEmpty()) { bindDeleteRequest(policy.getCandidatePaths().getCandidatePath(), writeContext).delete(instanceIdentifier); Ipv6Address bsid = Srv6Util.extractBsid(instanceIdentifier, writeContext, false); Preconditions.checkNotNull(bsid, "BSID must not be null"); policyContext.removePolicy(bsid, writeContext.getMappingContext()); } } PolicyCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final PolicyContextManager policyContext, @Nonnull final CandidatePathContextManager candidateContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext); }
@Test public void deleteCurrentAttributesTest() throws WriteFailedException { PolicyCustomizer customizer = new PolicyCustomizer(api, policyCtx, candidatePathCtx); customizer.deleteCurrentAttributes(Srv6PolicyIIds.SR_TE_PLS.child(Policy.class, POLICY_KEY), policies.getPolicy().get(0), ctx); verify(api, times(1)).srPolicyDel(requestcaptorDel.capture()); SrPolicyDel srPolicy = requestcaptorDel.getValue(); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(BSID_ADR)), srPolicy.bsidAddr.addr); }
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, prefix, writeContext, true).write(instanceIdentifier); } PrefixCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext); }
@Test public void writeCurrentAttributesV6Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.writeCurrentAttributes(L3_STEER_V6_IID, L3_STEERING_V6, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_FALSE, (byte) 6, true, BSID_ADR, IPV6_PREFIX); } @Test public void writeCurrentAttributesV4Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.writeCurrentAttributes(L3_STEER_V4_IID, L3_STEERING_V4, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_FALSE, (byte) 4, false, BSID_ADR, IPV4_PREFIX); }
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, prefix, writeContext, false).delete(instanceIdentifier); } PrefixCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext); }
@Test public void deleteCurrentAttributesV6Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.deleteCurrentAttributes(L3_STEER_V6_IID, L3_STEERING_V6, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_TRUE, (byte) 6, true, BSID_ADR, IPV6_PREFIX); } @Test public void deleteCurrentAttributesV4Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.deleteCurrentAttributes(L3_STEER_V4_IID, L3_STEERING_V4, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_TRUE, (byte) 4, false, BSID_ADR, IPV4_PREFIX); }
InterfacesConfigCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (anInterface.getConfig() != null) { writeInterfaces(instanceIdentifier, anInterface.getConfig(), writeContext, true); } } InterfacesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); }
@Test public void writeCurrentAttributesTest() throws WriteFailedException { InterfacesConfigCustomizer customizer = new InterfacesConfigCustomizer(api, interfaceContext); customizer.writeCurrentAttributes(L2_STEER_IID, L2_STEERING, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testRequestValidity(srSteering, ByteDataTranslator.BYTE_FALSE); }
InterfacesConfigCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (anInterface.getConfig() != null) { writeInterfaces(instanceIdentifier, anInterface.getConfig(), writeContext, false); } } InterfacesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); }
@Test public void deleteCurrentAttributesV6Test() throws WriteFailedException { InterfacesConfigCustomizer customizer = new InterfacesConfigCustomizer(api, interfaceContext); customizer.deleteCurrentAttributes(L2_STEER_IID, L2_STEERING, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testRequestValidity(srSteering, ByteDataTranslator.BYTE_TRUE); }
PrefixesConfigCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Config> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, config, writeContext, true); } PrefixesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext); }
@Test public void writeCurrentAttributes() throws WriteFailedException { PrefixesConfigCustomizer customizer = new PrefixesConfigCustomizer(api); customizer.writeCurrentAttributes(PREFIXES_CFG_IID, CONFIG, ctx); verify(api, times(2)).srSteeringAddDel(requestcaptor.capture()); List<SrSteeringAddDel> srSteerings = requestcaptor.getAllValues(); testSrSteeringAddDelValidity(srSteerings.get(0), ByteDataTranslator.BYTE_FALSE, L3SteeringRequest.VPP_IPV6_TYPE, true, BSID_ADR, DEFAULT_IPV6_PREFIX); testSrSteeringAddDelValidity(srSteerings.get(1), ByteDataTranslator.BYTE_FALSE, L3SteeringRequest.VPP_IPV4_TYPE, false, BSID_ADR, DEFAULT_IPV4_PREFIX); }
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey>, JvppReplyConsumer, ByteDataTranslator, Ipv6Translator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Removing Prefix {} dataBefore={}", id, dataBefore); setPrefix(id, dataBefore, writeContext, true); } PrefixCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete(@InjectTestData(resourcePath = "/ra/simplePrefix.json", id = RA_PATH) PrefixList prefixList) throws WriteFailedException { final Prefix data = getPrefix(prefixList); customizer.deleteCurrentAttributes(IID, data, writeContext); final SwInterfaceIp6NdRaPrefix request = new SwInterfaceIp6NdRaPrefix(); request.swIfIndex = IFC_INDEX; request.prefix = getPrefix( new byte[]{0x20, 0x01, 0x0d, (byte) 0xb8, 0x0a, 0x0b, 0x12, (byte) 0xf0, 0, 0, 0, 0, 0, 0, 0, 0x02}, (byte) 64); request.isNo = 1; verify(api).swInterfaceIp6NdRaPrefix(request); }
PrefixesConfigCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Config> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, config, writeContext, false); } PrefixesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext); }
@Test public void deleteCurrentAttributes() throws WriteFailedException { PrefixesConfigCustomizer customizer = new PrefixesConfigCustomizer(api); customizer.deleteCurrentAttributes(PREFIXES_CFG_IID, CONFIG, ctx); verify(api, times(2)).srSteeringAddDel(requestcaptor.capture()); List<SrSteeringAddDel> srSteerings = requestcaptor.getAllValues(); testSrSteeringAddDelValidity(srSteerings.get(0), ByteDataTranslator.BYTE_TRUE, L3SteeringRequest.VPP_IPV6_TYPE, true, BSID_ADR, DEFAULT_IPV6_PREFIX); testSrSteeringAddDelValidity(srSteerings.get(1), ByteDataTranslator.BYTE_TRUE, L3SteeringRequest.VPP_IPV4_TYPE, false, BSID_ADR, DEFAULT_IPV4_PREFIX); }
SidCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Sid, SidKey, SidBuilder> { @Nonnull @Override public List<SidKey> getAllIds(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull ReadContext readContext) throws ReadFailedException { return new LocalSidReadRequest(getFutureJVpp(), locatorContext, registry) .readAllKeys(instanceIdentifier, readContext); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, LocalSidFunctionReadBindingRegistry registry, @Nonnull final LocatorContextManager locatorContext); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull Sid sid, @Nonnull ReadContext readContext); @Nonnull @Override List<SidKey> getAllIds(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Sid> list); @Nonnull @Override SidBuilder getBuilder(@Nonnull InstanceIdentifier<Sid> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull SidBuilder sidBuilder, @Nonnull ReadContext readContext); }
@Test public void getAllIdsTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); srLocalsidsDetails.behavior = 1; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); SidCustomizer customizer = new SidCustomizer(api, READ_REGISTRY, locatorContext); List<SidKey> allIds = customizer.getAllIds(SID_A_101, readCtx); Assert.assertNotNull(allIds); Assert.assertFalse(allIds.isEmpty()); Assert.assertTrue(allIds.contains(SID_A_101.firstKeyOf(Sid.class))); }
LocalSidReadRequest extends JVppRequest implements ReadRequest<Sid, SidKey, SidBuilder> { @Override @Nonnull public List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx) throws ReadFailedException { final LocatorKey key = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class), "Identifier does not have %s ", LocatorKey.class); String locator = key.getName(); return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails .stream() .filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator)) .map(srLocalsidsDetails -> extractOpCode(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr), ctx.getMappingContext(), locator)) .map(SidKey::new) .collect(Collectors.toList()); } LocalSidReadRequest(final FutureJVppCore api, final LocatorContextManager locatorContext, final LocalSidFunctionReadBindingRegistry registry); @Override @Nonnull List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx); @Override void readSpecific(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx, @Nonnull SidBuilder builder); }
@Test public void readAllKeysTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; SrLocalsidsDetails srLocalsidsDetails2 = new SrLocalsidsDetails(); Srv6Sid sid2 = new Srv6Sid(); sid2.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR_2)); srLocalsidsDetails2.addr = sid2; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); replyDump.srLocalsidsDetails.add(srLocalsidsDetails2); final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY); request.checkValid(); List<SidKey> sidKeys = request.readAllKeys(ID_SID, readCtx); Assert.assertFalse(sidKeys.isEmpty()); Assert.assertEquals(2, sidKeys.size()); }
LocalSidReadRequest extends JVppRequest implements ReadRequest<Sid, SidKey, SidBuilder> { @Override public void readSpecific(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx, @Nonnull SidBuilder builder) throws ReadFailedException { final SidKey sidKey = Preconditions.checkNotNull(identifier.firstKeyOf(Sid.class), "Identifier does not contain %s ", SidKey.class); final LocatorKey locatorKey = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class), "Identifier does not contain %s ", Locator.class); Integer locLength = LocatorContextManager .parseLength(locatorContext.getLocator(locatorKey.getName(), ctx.getMappingContext())); Ipv6Address locator = LocatorContextManager .parseLocator(locatorContext.getLocator(locatorKey.getName(), ctx.getMappingContext())); Ipv6Address sidAddress = parseSrv6SidAddress(locator.getValue(), locLength.toString(), sidKey.getOpcode().getValue()); dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails .stream() .filter(detail -> Arrays.equals(detail.addr.addr, ipv6AddressNoZoneToArray(sidAddress))) .findFirst() .ifPresent(detail -> bindLocalSid(detail, ctx, locatorKey.getName(), sidAddress, builder)); } LocalSidReadRequest(final FutureJVppCore api, final LocatorContextManager locatorContext, final LocalSidFunctionReadBindingRegistry registry); @Override @Nonnull List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx); @Override void readSpecific(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx, @Nonnull SidBuilder builder); }
@Test public void readSpecificEndXTest() throws ReadFailedException { SrLocalsidsDetails endX = new SrLocalsidsDetails(); endX.behavior = 2; endX.endPsp = 0; endX.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(SID_ADR_2); endX.xconnectIfaceOrVrfTable = 1; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); endX.addr = sid; replyDump.srLocalsidsDetails.add(endX); final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY); SidBuilder sidBuilder = new SidBuilder(); request.readSpecific(ID_SID, readCtx, sidBuilder); Assert.assertNotNull(sidBuilder.getEndX()); Assert.assertEquals(EndX.class, sidBuilder.getEndBehaviorType()); Assert.assertEquals(OPERATION, sidBuilder.getOpcode().getValue().longValue()); Assert.assertNotNull(sidBuilder.getEndX().getPaths().getPath()); Assert.assertFalse(sidBuilder.getEndX().getPaths().getPath().isEmpty()); Assert.assertEquals(LOCAL_0, sidBuilder.getEndX().getPaths().getPath().get(0).getInterface()); Assert.assertEquals(ADDRESS_NO_ZONE, sidBuilder.getEndX().getPaths().getPath().get(0).getNextHop()); } @Test public void readSpecificEndTTest() throws ReadFailedException { SrLocalsidsDetails endT = new SrLocalsidsDetails(); endT.behavior = 3; endT.xconnectIfaceOrVrfTable = 4; endT.endPsp = 0; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); endT.addr = sid; replyDump.srLocalsidsDetails.add(endT); final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY); SidBuilder sidBuilder = new SidBuilder(); request.readSpecific(ID_SID, readCtx, sidBuilder); Assert.assertNotNull(sidBuilder.getEndT()); Assert.assertEquals(EndT.class, sidBuilder.getEndBehaviorType()); Assert.assertEquals(OPERATION, sidBuilder.getOpcode().getValue().longValue()); Assert.assertEquals(4L, sidBuilder.getEndT().getLookupTableIpv6().getValue().longValue()); }
LocatorReadRequest extends JVppRequest implements ReadRequest<Locator, LocatorKey, LocatorBuilder> { @Override @Nonnull public List<LocatorKey> readAllKeys(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx) throws ReadFailedException { return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails .stream() .map(srLocalsidsDetails -> extractLocator(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr), ctx.getMappingContext(), null).getValue()) .map(LocatorKey::new) .distinct() .collect(Collectors.toList()); } LocatorReadRequest(final FutureJVppCore api, LocatorContextManager locatorCtx); @Override @Nonnull List<LocatorKey> readAllKeys(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx); @Override void readSpecific(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx, @Nonnull LocatorBuilder builder); }
@Test public void readAllKeysTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; SrLocalsidsDetails srLocalsidsDetails2 = new SrLocalsidsDetails(); Srv6Sid sid2 = new Srv6Sid(); sid2.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR_2)); srLocalsidsDetails2.addr = sid2; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); replyDump.srLocalsidsDetails.add(srLocalsidsDetails2); final LocatorReadRequest request = new LocatorReadRequest(api, locatorContext); request.checkValid(); List<LocatorKey> locatorKeys = request.readAllKeys(ID_LOC, readCtx); Assert.assertFalse(locatorKeys.isEmpty()); Assert.assertEquals(2, locatorKeys.size()); Assert.assertTrue(locatorKeys.contains(new LocatorKey("a::"))); Assert.assertTrue(locatorKeys.contains(new LocatorKey("b::"))); }
LocatorReadRequest extends JVppRequest implements ReadRequest<Locator, LocatorKey, LocatorBuilder> { @Override public void readSpecific(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx, @Nonnull LocatorBuilder builder) throws ReadFailedException { final LocatorKey key = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class), "Identifier does not have %s ", LocatorKey.class); String locator = key.getName(); dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails .stream() .filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator)) .findFirst() .ifPresent(srLocalsidsDetails -> bindLocalSid(srLocalsidsDetails, ctx.getMappingContext(), locator, builder)); } LocatorReadRequest(final FutureJVppCore api, LocatorContextManager locatorCtx); @Override @Nonnull List<LocatorKey> readAllKeys(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx); @Override void readSpecific(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx, @Nonnull LocatorBuilder builder); }
@Test public void readSpecificEndXTest() throws ReadFailedException { SrLocalsidsDetails endX = new SrLocalsidsDetails(); endX.behavior = 2; endX.endPsp = 0; endX.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(SID_ADR_2); endX.xconnectIfaceOrVrfTable = 1; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); endX.addr = sid; replyDump.srLocalsidsDetails.add(endX); final LocatorReadRequest request = new LocatorReadRequest(api, locatorContext); LocatorBuilder builder = new LocatorBuilder(); request.readSpecific(ID_LOC, readCtx, builder); Assert.assertEquals(new LocatorKey("a::"), builder.key()); }
LocatorCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Locator, LocatorKey, LocatorBuilder> { @Nonnull @Override public List<LocatorKey> getAllIds(@Nonnull InstanceIdentifier<Locator> instanceIdentifier, @Nonnull ReadContext readContext) throws ReadFailedException { return new LocatorReadRequest(getFutureJVpp(), locatorContext).readAllKeys(instanceIdentifier, readContext); } LocatorCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final LocatorContextManager locatorContext); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Locator> instanceIdentifier, @Nonnull Locator locator, @Nonnull ReadContext readContext); @Nonnull @Override List<LocatorKey> getAllIds(@Nonnull InstanceIdentifier<Locator> instanceIdentifier, @Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Locator> locators); @Nonnull @Override LocatorBuilder getBuilder(@Nonnull InstanceIdentifier<Locator> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Locator> instanceIdentifier, @Nonnull LocatorBuilder locatorBuilder, @Nonnull ReadContext readContext); }
@Test public void getAllIdsTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); srLocalsidsDetails.behavior = 1; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); LocatorCustomizer customizer = new LocatorCustomizer(api, locatorContext); List<LocatorKey> allIds = customizer.getAllIds(SID_A_101.firstIdentifierOf(Locator.class), readCtx); Assert.assertNotNull(allIds); Assert.assertFalse(allIds.isEmpty()); Assert.assertTrue(allIds.contains(SID_A_101.firstKeyOf(Locator.class))); }
NamedSegmentCustomizer extends FutureJVppCustomizer implements ListReaderCustomizer<NamedSegmentList, NamedSegmentListKey, NamedSegmentListBuilder> { @Nonnull @Override public List<NamedSegmentListKey> getAllIds(@Nonnull final InstanceIdentifier<NamedSegmentList> instanceIdentifier, @Nonnull final ReadContext readContext) throws ReadFailedException { PolicyReadRequest policyReadRequest = new PolicyReadRequest(getFutureJVpp(), policyContext, candidateContext); policyReadRequest.checkValid(); return policyReadRequest.readNamedSegmentListKeys(instanceIdentifier, readContext); } NamedSegmentCustomizer(@Nonnull final FutureJVppCore futureJVppCore, final PolicyContextManager policyContext, final CandidatePathContextManager candidateContext); @Nonnull @Override List<NamedSegmentListKey> getAllIds(@Nonnull final InstanceIdentifier<NamedSegmentList> instanceIdentifier, @Nonnull final ReadContext readContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<NamedSegmentList> list); @Nonnull @Override NamedSegmentListBuilder getBuilder(@Nonnull final InstanceIdentifier<NamedSegmentList> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<NamedSegmentList> instanceIdentifier, @Nonnull final NamedSegmentListBuilder builder, @Nonnull final ReadContext readContext); }
@Test public void getAllIdsTest() throws ReadFailedException { NamedSegmentCustomizer customizer = new NamedSegmentCustomizer(api, policyCtx, candidatePathCtx); List<NamedSegmentListKey> segmentListKeys = customizer.getAllIds(Srv6PolicyIIds.SR_TE_NSLS_NSL_IID, readCtx); Assert.assertNotNull(segmentListKeys); Assert.assertFalse(segmentListKeys.isEmpty()); Assert.assertEquals(replyDump.srPoliciesDetails.size(), segmentListKeys.size()); Assert.assertTrue(segmentListKeys.containsAll(ImmutableSet.of(SEGMENT_KEY_1, SEGMENT_KEY_2))); }
PolicyCustomizer extends FutureJVppCustomizer implements ListReaderCustomizer<Policy, PolicyKey, PolicyBuilder> { @Nonnull @Override public List<PolicyKey> getAllIds(@Nonnull InstanceIdentifier<Policy> id, @Nonnull ReadContext context) throws ReadFailedException { PolicyReadRequest policyReadRequest = new PolicyReadRequest(getFutureJVpp(), policyContext, candidateContext); return policyReadRequest.readAllKeys(id, context); } PolicyCustomizer(@Nonnull final FutureJVppCore futureJVppCore, PolicyContextManager policyContext, final CandidatePathContextManager candidateContext); @Nonnull @Override List<PolicyKey> getAllIds(@Nonnull InstanceIdentifier<Policy> id, @Nonnull ReadContext context); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Policy> readData); @Nonnull @Override PolicyBuilder getBuilder(@Nonnull InstanceIdentifier<Policy> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Policy> id, @Nonnull PolicyBuilder builder, @Nonnull ReadContext ctx); }
@Test public void getAllIdsTest() throws ReadFailedException { PolicyCustomizer customizer = new PolicyCustomizer(api, policyCtx, candidatePathCtx); List<PolicyKey> policyKeys = customizer.getAllIds(Srv6PolicyIIds.SR_TE_PLS_POL, readCtx); Assert.assertNotNull(policyKeys); Assert.assertFalse(policyKeys.isEmpty()); Assert.assertEquals(replyDump.srPoliciesDetails.size(), policyKeys.size()); Assert.assertTrue(policyKeys.containsAll(ImmutableSet.of(POLICY_KEY, POLICY_KEY_2))); }
Ipv6RouteCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Route, RouteKey>, JvppReplyConsumer, RouteMapper { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String parentProtocolName = instanceIdentifier.firstKeyOf(ControlPlaneProtocol.class).getName(); final String routeName = namesFactory.uniqueRouteName(parentProtocolName, route); Optional<ControlPlaneProtocol> protocolOptional = writeContext.readAfter(RWUtils.cutId(instanceIdentifier, ControlPlaneProtocol.class)); Preconditions.checkArgument(protocolOptional.isPresent(), "Control protocol cannot be null for route: {}", instanceIdentifier); TableKey key = new TableKey( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.Ipv6.class, new VniReference(ControlPlaneProtocolCustomizer.extractTableId(protocolOptional.get()))); if (!ControlPlaneProtocolCustomizer.isTablePresent(key, writeContext)) { throw new WriteFailedException(instanceIdentifier, "Ipv6 FIB table does not exist!"); } writeRoute(instanceIdentifier, parentProtocolName, routeName, route, writeContext, true); routesContext.addName(routeName, writeContext.getMappingContext()); } Ipv6RouteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext, @Nonnull final NamingContext routesContext, @Nonnull final NamingContext routingProtocolContext, @Nonnull final MultiNamingContext routesHopsContext, @Nonnull final VppClassifierContextManager classifierContextManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); }
@Test(expected = WriteFailedException.class) public void testWriteSingleInvalidHop( @InjectTestData(resourcePath = "/ipv6/simplehop/simpleHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.writeCurrentAttributes(ROUTE_INVALID_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(0, ImmutableList.of(), api, requestCaptor); } @Test public void testWriteSingleHop( @InjectTestData(resourcePath = "/ipv6/simplehop/simpleHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.writeCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(1, 1, 0, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 0, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); } @Test public void testWriteSingleHop128( @InjectTestData(resourcePath = "/ipv6/simplehop/simpleHopRoute128.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.writeCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX_128), writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(1, 1, 0, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 128, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 0, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); } @Test public void testWriteTableLookup() throws WriteFailedException { final Route route = new RouteBuilder() .withKey(new RouteKey(IPV_6_PREFIX)) .setDestinationPrefix(IPV_6_PREFIX) .setNextHop(new NextHopBuilder().setNextHopOptions(new TableLookupCaseBuilder() .setSecondaryVrf(new VniReference(4L)) .setAddressFamily( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.fib.table.management.rev180521.Ipv6.class) .build()).build()) .build(); whenAddRouteThenSuccess(api); noMappingDefined(mappingContext, namesFactory.uniqueRouteName(ROUTE_PROTOCOL_NAME, route), "route-context"); customizer.writeCurrentAttributes(ROUTE_IID, route, writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(1, 1, 0, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, new byte[4], ~0, 0, TABLE_ID.intValue(), 4, 0, 0)), api, requestCaptor); } @Test public void testWriteHopList( @InjectTestData(resourcePath = "/ipv6/multihop/multiHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.writeCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(2, ImmutableList.of( desiredFlaglessResult(1, 1, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 2, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1), desiredFlaglessResult(1, 1, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 2, TABLE_ID.intValue(), 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); } @Test public void testWriteSpecialHop( @InjectTestData(resourcePath = "/ipv6/specialhop/specialHopRouteBlackhole.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.writeCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(1, ImmutableList .of(desiredSpecialResult(1, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, 1, 0, 0, 0, TABLE_ID.intValue(), 0)), api, requestCaptor); }
PrefixCustomizer extends FutureJVppCustomizer implements ListReaderCustomizer<Prefix, PrefixKey, PrefixBuilder> { @Nonnull @Override public List<PrefixKey> getAllIds(@Nonnull InstanceIdentifier<Prefix> id, @Nonnull ReadContext context) throws ReadFailedException { return new L3SteeringRequest(getFutureJVpp()).readAllKeys(id, context); } PrefixCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Nonnull @Override List<PrefixKey> getAllIds(@Nonnull InstanceIdentifier<Prefix> id, @Nonnull ReadContext context); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Prefix> readData); @Nonnull @Override PrefixBuilder getBuilder(@Nonnull InstanceIdentifier<Prefix> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Prefix> id, @Nonnull PrefixBuilder builder, @Nonnull ReadContext ctx); }
@Test public void getAllIdsTest() throws ReadFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); List<PrefixKey> l3SteeringKeys = customizer.getAllIds(Srv6PolicyIIds.SR_TE_PLS_POL_AI_PFS_PF_IID, readCtx); Assert.assertNotNull(l3SteeringKeys); Assert.assertFalse(l3SteeringKeys.isEmpty()); Assert.assertEquals(2, l3SteeringKeys.size()); Assert.assertTrue(l3SteeringKeys.containsAll(ImmutableSet.of(L3_KEY, L3_KEY_2))); }
InterfaceCustomizer extends FutureJVppCustomizer implements ListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder> { @Nonnull @Override public List<InterfaceKey> getAllIds(@Nonnull InstanceIdentifier<Interface> id, @Nonnull ReadContext context) throws ReadFailedException { return new L2SteeringRequest(getFutureJVpp(), interfaceContext).readAllKeys(id, context); } InterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Nonnull @Override List<InterfaceKey> getAllIds(@Nonnull InstanceIdentifier<Interface> id, @Nonnull ReadContext context); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Interface> readData); @Nonnull @Override InterfaceBuilder getBuilder(@Nonnull InstanceIdentifier<Interface> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Interface> id, @Nonnull InterfaceBuilder builder, @Nonnull ReadContext ctx); }
@Test public void getAllIdsTest() throws ReadFailedException { InterfaceCustomizer customizer = new InterfaceCustomizer(api, interfaceContext); List<InterfaceKey> l2SteeringKeys = customizer.getAllIds(Srv6PolicyIIds.SR_TE_PLS_POL_AI_IFCS_IFC, readCtx); Assert.assertNotNull(l2SteeringKeys); Assert.assertFalse(l2SteeringKeys.isEmpty()); Assert.assertEquals(1, l2SteeringKeys.size()); Assert.assertTrue(l2SteeringKeys.containsAll(ImmutableSet.of(L2_KEY))); }
PolicyValidator implements Validator<Policy> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { try { validatePolicy(id, dataAfter); } catch (RuntimeException e) { throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy dataAfter, @Nonnull final WriteContext writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testInvalidPolicyId() throws CreateValidationFailedException { validator.validateWrite(INVALID_POLICY_ID, mock(Policy.class), writeContext); } @Test public void testNoNat64Prefixes() throws CreateValidationFailedException { validator.validateWrite(DEFAULT_POLICY_ID, mock(Policy.class), writeContext); } @Test public void testSingleNat64Prefix() throws CreateValidationFailedException { final Policy policy = new PolicyBuilder().setNat64Prefixes(Collections.singletonList(P1)).build(); validator.validateWrite(DEFAULT_POLICY_ID, policy, writeContext); } @Test(expected = CreateValidationFailedException.class) public void testTwoNat64Prefixes() throws CreateValidationFailedException { final Policy policy = new PolicyBuilder().setNat64Prefixes(Arrays.asList(P1, P2)).build(); validator.validateWrite(DEFAULT_POLICY_ID, policy, writeContext); }
MappingEntryValidator implements Validator<MappingEntry>, Ipv4Translator, Ipv6Translator { @Override public void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext) throws CreateValidationFailedException { try { validateMappingEntry(id, mappingEntry); } catch (RuntimeException e) { throw new CreateValidationFailedException(id, mappingEntry, e); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext); }
@Test public void testWriteNat44( @InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException, DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, extractMappingEntry(data), writeContext); } @Test(expected = DataValidationFailedException.CreateValidationFailedException.class) public void testWriteNat44UnsupportedProtocol( @InjectTestData(resourcePath = "/nat44/static-mapping-unsupported-proto.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException, DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, extractMappingEntry(data), writeContext); }
MappingEntryValidator implements Validator<MappingEntry>, Ipv4Translator, Ipv6Translator { @VisibleForTesting void validateMappingEntryType(final MappingEntry mappingEntry) { checkArgument(mappingEntry.getType() == org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev180628.MappingEntry.Type.Static, "Only static NAT entries are supported currently. Trying to write: %s entry", mappingEntry.getType()); } @Override void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext); }
@Test(expected = IllegalArgumentException.class) public void testUnsupportedMappingEntryType() { final MappingEntry mappingEntry = mock(MappingEntry.class); when(mappingEntry.getType()).thenReturn(Type.DynamicExplicit); validator.validateMappingEntryType(mappingEntry); }
MappingEntryValidator implements Validator<MappingEntry>, Ipv4Translator, Ipv6Translator { @VisibleForTesting void validateInternalSrcAddress(final MappingEntry mappingEntry) { final IpPrefix internalSrcPrefix = mappingEntry.getInternalSrcAddress(); final Ipv4Prefix internalV4SrcPrefix = internalSrcPrefix.getIpv4Prefix(); final Ipv6Prefix internalV6SrcPrefix = internalSrcPrefix.getIpv6Prefix(); if (internalV4SrcPrefix != null) { checkArgument(extractPrefix(internalV4SrcPrefix) == 32, "Only /32 prefix in internal-src-address is supported, but was %s", internalV4SrcPrefix); } else { checkState(internalV6SrcPrefix != null, "internalSrcPrefix.getIpv6Prefix() should not return null if Ipv4 prefix is not given"); checkArgument(extractPrefix(internalV6SrcPrefix) == (byte) 128, "Only /128 prefix in internal-src-address is supported, but was %s", internalV6SrcPrefix); } } @Override void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext); }
@Test(expected = IllegalArgumentException.class) public void testInvalidInternalIpv6SrcAddressPrefix() { final MappingEntry mappingEntry = mock(MappingEntry.class); final IpPrefix address = new IpPrefix(new Ipv6Prefix("1::1/127")); when(mappingEntry.getInternalSrcAddress()).thenReturn(address); validator.validateInternalSrcAddress(mappingEntry); } @Test(expected = IllegalArgumentException.class) public void testInvalidInternalIpv4SrcAddressPrefix() { final MappingEntry mappingEntry = mock(MappingEntry.class); final IpPrefix address = new IpPrefix(new Ipv4Prefix("1.2.3.4/16")); when(mappingEntry.getInternalSrcAddress()).thenReturn(address); validator.validateInternalSrcAddress(mappingEntry); }
MappingEntryValidator implements Validator<MappingEntry>, Ipv4Translator, Ipv6Translator { @VisibleForTesting void validateExternalSrcAddress(final MappingEntry mappingEntry) { final IpPrefix externalSrcAddress = mappingEntry.getExternalSrcAddress(); checkArgument(externalSrcAddress != null, "The external-src-address leaf is missing"); final Ipv4Prefix ipv4Prefix = externalSrcAddress.getIpv4Prefix(); checkArgument(ipv4Prefix != null, "No Ipv4 present in external-src-address %s", externalSrcAddress); checkArgument(extractPrefix(ipv4Prefix) == 32, "Only /32 prefix in external-src-address is supported, but was %s", ipv4Prefix); } @Override void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext); }
@Test(expected = IllegalArgumentException.class) public void testInvalidExternalSrcAddress() { final MappingEntry mappingEntry = mock(MappingEntry.class); final IpPrefix address = new IpPrefix(new Ipv4Prefix("1.2.3.4/16")); when(mappingEntry.getExternalSrcAddress()).thenReturn(address); validator.validateExternalSrcAddress(mappingEntry); }
MappingEntryValidator implements Validator<MappingEntry>, Ipv4Translator, Ipv6Translator { @VisibleForTesting static void validatePortNumber(final InstanceIdentifier<MappingEntry> id, final PortNumber portNumber) { if (portNumber == null) { return; } checkArgument(portNumber.getStartPortNumber() != null && portNumber.getEndPortNumber() == null, "Only single port number supported. Submitted: %s for entry: %s", portNumber, id); } @Override void validateWrite(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry mappingEntry, @Nonnull final WriteContext writeContext); }
@Test(expected = IllegalArgumentException.class) public void testInvalidPortNumber() { InternalSrcPort port = new InternalSrcPortBuilder() .setStartPortNumber(new PortNumber(10)) .setEndPortNumber(new PortNumber(20)) .build(); final InstanceIdentifier<MappingEntry> id = InstanceIdentifier.create(MappingEntry.class); MappingEntryValidator.validatePortNumber(id, port); }
ExternalIpPoolCustomizer implements ListWriterCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolKey>, JvppReplyConsumer, Ipv4Translator, ByteDataTranslator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.trace("Adding address range:{}, as: {}", id, dataAfter); configureAddressPool(id, dataAfter, true); LOG.debug("Address range: {} added successfully", id); } ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWriteNat44( @InjectTestData(resourcePath = "/nat44/external-ip-pool.json", id = NAT_INSTANCES_PATH) Instances data) throws WriteFailedException { customizer.writeCurrentAttributes(IID, extractIpPool(data), writeContext); final Nat44AddDelAddressRange expectedRequest = getExpectedRequestNat44(true); verify(jvppNat).nat44AddDelAddressRange(expectedRequest); } @Test public void testWriteNat64( @InjectTestData(resourcePath = "/nat64/external-ip-pool.json", id = NAT_INSTANCES_PATH) Instances data) throws WriteFailedException { customizer.writeCurrentAttributes(IID, extractIpPool(data), writeContext); final Nat64AddDelPoolAddrRange expectedRequest = getExpectedRequestNat64(true); verify(jvppNat).nat64AddDelPoolAddrRange(expectedRequest); }
ExternalIpPoolCustomizer implements ListWriterCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolKey>, JvppReplyConsumer, Ipv4Translator, ByteDataTranslator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.trace("Deleting address range:{}, as: {}", id, dataBefore); configureAddressPool(id, dataBefore, false); LOG.debug("Deleting range: {} added successfully", id); } ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteNat44( @InjectTestData(resourcePath = "/nat44/external-ip-pool.json", id = NAT_INSTANCES_PATH) Instances data) throws WriteFailedException { customizer.deleteCurrentAttributes(IID, extractIpPool(data), writeContext); final Nat44AddDelAddressRange expectedRequest = getExpectedRequestNat44(false); verify(jvppNat).nat44AddDelAddressRange(expectedRequest); } @Test public void testDeleteNat64( @InjectTestData(resourcePath = "/nat64/external-ip-pool.json", id = NAT_INSTANCES_PATH) Instances data) throws WriteFailedException { customizer.deleteCurrentAttributes(IID, extractIpPool(data), writeContext); final Nat64AddDelPoolAddrRange expectedRequest = getExpectedRequestNat64(false); verify(jvppNat).nat64AddDelPoolAddrRange(expectedRequest); }
Nat64PrefixesCustomizer implements ListWriterCustomizer<Nat64Prefixes, Nat64PrefixesKey>, ByteDataTranslator, Ipv6Translator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final int natInstanceId = id.firstKeyOf(Instance.class).getId().intValue(); LOG.debug("Configuring nat64 prefix: {} for nat-instance(vrf): {}", dataAfter, natInstanceId); addDelPrefix(id, dataAfter, natInstanceId, true); LOG.debug("Nat64 prefix written successfully: {} for nat-instance(vrf): {}", dataAfter, natInstanceId); } Nat64PrefixesCustomizer(final FutureJVppNatFacade jvppNat); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws Exception { customizer.writeCurrentAttributes(getID("::1/128"), VALID_DATA, writeContext); verify(jvppNat).nat64AddDelPrefix(expectedRequest(true)); }
Nat64PrefixesCustomizer implements ListWriterCustomizer<Nat64Prefixes, Nat64PrefixesKey>, ByteDataTranslator, Ipv6Translator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final int natInstanceId = id.firstKeyOf(Instance.class).getId().intValue(); LOG.debug("Removing nat64 prefix configuration: {} for nat-instance(vrf): {}", dataBefore, natInstanceId); addDelPrefix(id, dataBefore, natInstanceId, false); LOG.debug("Nat64 prefix removed successfully: {} for nat-instance(vrf): {}", dataBefore, natInstanceId); } Nat64PrefixesCustomizer(final FutureJVppNatFacade jvppNat); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64Prefixes dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws Exception { customizer.deleteCurrentAttributes(getID("::1/128"), VALID_DATA, writeContext); verify(jvppNat).nat64AddDelPrefix(expectedRequest(false)); }
MappingEntryCustomizer implements ListWriterCustomizer<MappingEntry, MappingEntryKey>, JvppReplyConsumer, Ipv4Translator, Ipv6Translator, ByteDataTranslator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final Long natInstanceId = id.firstKeyOf(Instance.class).getId(); final Long mappingEntryId = id.firstKeyOf(MappingEntry.class).getIndex(); LOG.debug("Writing mapping entry: {} for nat-instance(vrf): {}", natInstanceId, mappingEntryId); configureMapping(id, dataAfter, natInstanceId, true); synchronized (mappingEntryContext) { if (shouldStoreContextMapping(natInstanceId, mappingEntryId, dataAfter, writeContext)) { mappingEntryContext .addEntry(natInstanceId, mappingEntryId, dataAfter, writeContext.getMappingContext()); } } LOG.trace("Mapping entry: {} for nat-instance(vrf): {} written successfully", natInstanceId, id); } MappingEntryCustomizer(final FutureJVppNatFacade jvppNat, final MappingEntryContext mappingEntryContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testWriteNat44( @InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException { customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext); final Nat44AddDelStaticMapping expectedRequest = getExpectedNat44Request(); expectedRequest.isAdd = true; verify(jvppNat).nat44AddDelStaticMapping(expectedRequest); } @Test public void testWriteNat64( @InjectTestData(resourcePath = "/nat64/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException { customizer.writeCurrentAttributes(IID, extractMappingEntry(data), writeContext); final Nat64AddDelStaticBib expectedRequest = getExpectedNat64Request(); expectedRequest.isAdd = true; verify(jvppNat).nat64AddDelStaticBib(expectedRequest); }
MappingEntryCustomizer implements ListWriterCustomizer<MappingEntry, MappingEntryKey>, JvppReplyConsumer, Ipv4Translator, Ipv6Translator, ByteDataTranslator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final long natInstanceId = id.firstKeyOf(Instance.class).getId(); final MappingEntryKey mappingEntryKey = id.firstKeyOf(MappingEntry.class); LOG.debug("Deleting mapping entry: {} for nat-instance(vrf): {}", natInstanceId, mappingEntryKey); configureMapping(id, dataBefore, natInstanceId, false); mappingEntryContext.removeEntry(natInstanceId, dataBefore, writeContext.getMappingContext()); LOG.trace("Mapping entry: {} for nat-instance(vrf): {} deleted successfully", natInstanceId, id); } MappingEntryCustomizer(final FutureJVppNatFacade jvppNat, final MappingEntryContext mappingEntryContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry dataBefore, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteNat44( @InjectTestData(resourcePath = "/nat44/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException { customizer.deleteCurrentAttributes(IID, extractMappingEntry(data), writeContext); verify(jvppNat).nat44AddDelStaticMapping(getExpectedNat44Request()); } @Test public void testDeleteNat64( @InjectTestData(resourcePath = "/nat64/static-mapping.json", id = MAPPING_TABLE_PATH) MappingTable data) throws WriteFailedException { customizer.deleteCurrentAttributes(IID, extractMappingEntry(data), writeContext); verify(jvppNat).nat64AddDelStaticBib(getExpectedNat64Request()); }
NatInstanceCustomizer implements InitializingListReaderCustomizer<Instance, InstanceKey, InstanceBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final InstanceBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.trace("Reading current attributes for nat-instance: {}", id); builder.setId(id.firstKeyOf(Instance.class).getId()); } NatInstanceCustomizer( final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager, final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager); @Nonnull @Override InstanceBuilder getBuilder(@Nonnull final InstanceIdentifier<Instance> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final InstanceBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<InstanceKey> getAllIds(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Instance> readData); @Override Initialized<Instance> init( @Nonnull final InstanceIdentifier<Instance> id, @Nonnull final Instance readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws ReadFailedException { final InstanceBuilder builder = mock(InstanceBuilder.class); getCustomizer().readCurrentAttributes(natInstanceId, builder, ctx); verify(builder).setId(natInstanceId.getKey().getId()); }
NatInstanceCustomizer implements InitializingListReaderCustomizer<Instance, InstanceKey, InstanceBuilder> { @Nonnull @Override public List<InstanceKey> getAllIds(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final ReadContext context) throws ReadFailedException { LOG.trace("Listing IDs for all nat-instances"); final List<InstanceKey> vrfIds = Stream.concat( nat44DumpManager.getDump(id, context.getModificationCache()) .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream() .map(detail -> detail.vrfId), nat64DumpManager.getDump(id, context.getModificationCache()) .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream() .map(detail -> detail.vrfId)) .distinct() .map(vrfId -> new InstanceKey((long) vrfId)) .collect(Collectors.toList()); if (!vrfIds.contains(DEFAULT_VRF_ID)) { vrfIds.add(0, DEFAULT_VRF_ID); } LOG.debug("List of nat-instance keys (vrf-ids): {}", vrfIds); return vrfIds; } NatInstanceCustomizer( final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager, final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager); @Nonnull @Override InstanceBuilder getBuilder(@Nonnull final InstanceIdentifier<Instance> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final InstanceBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<InstanceKey> getAllIds(@Nonnull final InstanceIdentifier<Instance> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Instance> readData); @Override Initialized<Instance> init( @Nonnull final InstanceIdentifier<Instance> id, @Nonnull final Instance readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadAll() throws ReadFailedException { when(nat44DumpExecutor.executeDump(natInstanceWildcarded, null)).thenReturn(nat44NonEmptyDump()); when(nat64DumpExecutor.executeDump(natInstanceWildcarded, null)).thenReturn(nat64NonEmptyDump()); final List<InstanceKey> allIds = getCustomizer().getAllIds(natInstanceWildcarded, ctx); assertThat(allIds, hasSize(6)); assertThat(allIds, hasItems( new InstanceKey(0L), new InstanceKey(1L), new InstanceKey(2L), new InstanceKey(3L), new InstanceKey(5L), new InstanceKey(6L))); }
ExternalIpPoolCustomizer implements InitializingListReaderCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolKey, ExternalIpAddressPoolBuilder>, JvppReplyConsumer, Ipv4Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPoolBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.trace("Reading current attributes for external IP pool: {}", id); final Long poolId = id.firstKeyOf(ExternalIpAddressPool.class).getPoolId(); final List<Nat44AddressDetails> nat44Details = nat44DumpMgr.getDump(id, ctx.getModificationCache()) .orElse(new Nat44AddressDetailsReplyDump()).nat44AddressDetails; final int nat44PoolCount = nat44Details.size(); if (poolId < nat44PoolCount) { final Nat44AddressDetails detail = nat44Details.get(Math.toIntExact(poolId)); readPoolIp(builder, detail.ipAddress.ip4Address); setPoolType(builder, NatPoolType.Nat44); } else { final List<Nat64PoolAddrDetails> nat64Details = nat64DumpMgr.getDump(id, ctx.getModificationCache()) .orElse(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails; final int nat64PoolCount = nat64Details.size(); final int nat64PoolPosition = Math.toIntExact(poolId) - nat44PoolCount; if (nat64PoolPosition < nat64PoolCount) { final Nat64PoolAddrDetails detail = nat64Details.get(nat64PoolPosition); readPoolIp(builder, detail.address.ip4Address); setPoolType(builder, NatPoolType.Nat64); } else { LOG.trace("External IP pool: {} not found (nat44PoolCount={}, nat64PoolCount={})", id, nat44PoolCount, nat64PoolCount); return; } } builder.setPoolId(poolId); LOG.trace("External IP pool: {}. Read as: {}", id, builder); } ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Nonnull @Override ExternalIpAddressPoolBuilder getBuilder(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPoolBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ExternalIpAddressPoolKey> getAllIds(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<ExternalIpAddressPool> readData); @Override Initialized<ExternalIpAddressPool> init( @Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadAttributesNat44() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty())); final long poolId = 2; final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder(); getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx); assertEquals("192.168.44.3/32", builder.getExternalIpPool().getValue()); assertEquals(poolId, builder.getPoolId().longValue()); assertEquals(Nat44, builder.augmentation(ExternalIpAddressPoolAugmentation.class).getPoolType()); } @Test public void testReadAttributesNat64() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty())); final long poolId = 2; final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder(); getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx); assertEquals("192.168.64.3/32", builder.getExternalIpPool().getValue()); assertEquals(poolId, builder.getPoolId().longValue()); assertEquals(Nat64, builder.augmentation(ExternalIpAddressPoolAugmentation.class).getPoolType()); } @Test public void testReadAttributes() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty())); final long poolId = 5; final ExternalIpAddressPoolBuilder builder = new ExternalIpAddressPoolBuilder(); getCustomizer().readCurrentAttributes(getId(poolId), builder, ctx); assertEquals("192.168.64.3/32", builder.getExternalIpPool().getValue()); assertEquals(poolId, builder.getPoolId().longValue()); assertEquals(Nat64, builder.augmentation(ExternalIpAddressPoolAugmentation.class).getPoolType()); }
ExternalIpPoolCustomizer implements InitializingListReaderCustomizer<ExternalIpAddressPool, ExternalIpAddressPoolKey, ExternalIpAddressPoolBuilder>, JvppReplyConsumer, Ipv4Translator { @Nonnull @Override public List<ExternalIpAddressPoolKey> getAllIds(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceKey natKey = id.firstKeyOf(Instance.class); if (!natKey.equals(NatInstanceCustomizer.DEFAULT_VRF_ID)) { return Collections.emptyList(); } LOG.trace("Listing IDs for all external IP pools within nat-instance(vrf):{}", natKey); long addressCount = (long) nat44DumpMgr.getDump(id, ctx.getModificationCache()) .orElse(new Nat44AddressDetailsReplyDump()).nat44AddressDetails.size(); addressCount += (long) nat64DumpMgr.getDump(id, ctx.getModificationCache()) .orElse(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails.size(); final List<ExternalIpAddressPoolKey> ids = LongStream.range(0, addressCount) .mapToObj(ExternalIpAddressPoolKey::new) .collect(Collectors.toList()); LOG.trace("List of external IP pool ids: {}", ids); return ids; } ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Nonnull @Override ExternalIpAddressPoolBuilder getBuilder(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPoolBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<ExternalIpAddressPoolKey> getAllIds(@Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<ExternalIpAddressPool> readData); @Override Initialized<ExternalIpAddressPool> init( @Nonnull final InstanceIdentifier<ExternalIpAddressPool> id, @Nonnull final ExternalIpAddressPool readValue, @Nonnull final ReadContext ctx); }
@Test public void testGetAllNat44() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty())); final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx); assertThat(allIds, hasItems( LongStream.range(0, 2).mapToObj(ExternalIpAddressPoolKey::new) .toArray(ExternalIpAddressPoolKey[]::new))); } @Test public void testGetAllNat64() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty())); final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx); assertThat(allIds, hasItems( LongStream.range(0, 2).mapToObj(ExternalIpAddressPoolKey::new) .toArray(ExternalIpAddressPoolKey[]::new))); } @Test public void testGetAll() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44NonEmpty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64NonEmpty())); final List<ExternalIpAddressPoolKey> allIds = getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx); assertThat(allIds, hasItems( LongStream.range(0, 5).mapToObj(ExternalIpAddressPoolKey::new) .toArray(ExternalIpAddressPoolKey[]::new))); } @Test public void testGetAllDifferentInstance() throws Exception { assertThat(getCustomizer().getAllIds(NAT_NON_DEFAULT_POOL_WILDCARDED_ID, ctx), empty()); } @Test public void testGetAllNoDump() throws Exception { when(jvppNat.nat44AddressDump(any())).thenReturn(future(dumpReplyNat44Empty())); when(jvppNat.nat64PoolAddrDump(any())).thenReturn(future(dumpReplyNat64Empty())); assertThat(getCustomizer().getAllIds(NAT_DEFAULT_POOL_WILDCARDED_ID, ctx), empty()); }
Nat64PrefixesCustomizer implements ListReaderCustomizer<Nat64Prefixes, Nat64PrefixesKey, Nat64PrefixesBuilder>, JvppReplyConsumer, Ipv6Translator { @Nonnull @Override public List<Nat64PrefixesKey> getAllIds(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final ReadContext context) throws ReadFailedException { final InstanceKey natKey = id.firstKeyOf(Instance.class); LOG.trace("Listing IDs for all nat64 prefixes within nat-instance(vrf): {}", natKey); final Map<Long, Nat64PrefixDetails> prefixesByVrfId = dumpManager.getDump(id, context.getModificationCache()).get(); final Nat64PrefixDetails details = prefixesByVrfId.get(natKey.getId()); if (details != null) { return Collections.singletonList(new Nat64PrefixesKey(readPrefix(details))); } else { return Collections.emptyList(); } } Nat64PrefixesCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Nonnull @Override List<Nat64PrefixesKey> getAllIds(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Nat64Prefixes> readData); @Nonnull @Override Nat64PrefixesBuilder getBuilder(@Nonnull final InstanceIdentifier<Nat64Prefixes> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64PrefixesBuilder builder, @Nonnull final ReadContext context); }
@Test public void testGetAllNoPrefixes() throws ReadFailedException { when(jvppNat.nat64PrefixDump(any())).thenReturn(future(dump())); final List<Nat64PrefixesKey> allIds = getCustomizer().getAllIds(getWildcardedId(123), ctx); assertEquals(0, allIds.size()); } @Test public void testGetAll() throws ReadFailedException { when(jvppNat.nat64PrefixDump(any())).thenReturn(future(dump())); final long vrfId = 0; final List<Nat64PrefixesKey> allIds = getCustomizer().getAllIds(getWildcardedId(vrfId), ctx); assertEquals(1, allIds.size()); assertEquals(new Nat64PrefixesKey(new Ipv6Prefix("64:ff9b::1/96")), allIds.get(0)); }
Nat64PrefixesCustomizer implements ListReaderCustomizer<Nat64Prefixes, Nat64PrefixesKey, Nat64PrefixesBuilder>, JvppReplyConsumer, Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64PrefixesBuilder builder, @Nonnull final ReadContext context) throws ReadFailedException { LOG.trace("Reading nat64-prefixes: {}", id); final Map<Long, Nat64PrefixDetails> prefixesByVrfId = dumpManager.getDump(id, context.getModificationCache()).get(); final Nat64PrefixDetails details = prefixesByVrfId.get(id.firstKeyOf(Instance.class).getId()); if (details != null) { builder.setNat64Prefix(readPrefix(details)); } } Nat64PrefixesCustomizer(@Nonnull final FutureJVppNatFacade jvppNat); @Nonnull @Override List<Nat64PrefixesKey> getAllIds(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Nat64Prefixes> readData); @Nonnull @Override Nat64PrefixesBuilder getBuilder(@Nonnull final InstanceIdentifier<Nat64Prefixes> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Nat64Prefixes> id, @Nonnull final Nat64PrefixesBuilder builder, @Nonnull final ReadContext context); }
@Test public void testReadMissingForGivenVrf() throws ReadFailedException { final long vrfId = 123; when(jvppNat.nat64PrefixDump(any())).thenReturn(future(dump())); final Nat64PrefixesBuilder builder = mock(Nat64PrefixesBuilder.class); getCustomizer().readCurrentAttributes(getId(vrfId, "::1/128"), builder, ctx); verifyZeroInteractions(builder); } @Test public void testRead() throws ReadFailedException { final long vrfId = 1; when(jvppNat.nat64PrefixDump(any())).thenReturn(future(dump())); final Nat64PrefixesBuilder builder = mock(Nat64PrefixesBuilder.class); getCustomizer().readCurrentAttributes(getId(vrfId, "::1/128"), builder, ctx); verify(builder).setNat64Prefix(new Ipv6Prefix("::1/128")); }
PolicyCustomizer implements InitializingListReaderCustomizer<Policy, PolicyKey, PolicyBuilder> { @Nonnull @Override public List<PolicyKey> getAllIds(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final ReadContext context) throws ReadFailedException { return IDS; } @Nonnull @Override PolicyBuilder getBuilder(@Nonnull final InstanceIdentifier<Policy> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final PolicyBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<PolicyKey> getAllIds(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Policy> readData); @Override Initialized<Policy> init( @Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy readValue, @Nonnull final ReadContext ctx); }
@Test public void testGetAllIds() throws ReadFailedException { assertThat(getCustomizer().getAllIds(NatIds.POLICY_ID, ctx), hasItems(new PolicyKey(0L))); }
PolicyCustomizer implements InitializingListReaderCustomizer<Policy, PolicyKey, PolicyBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final PolicyBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final Long policyId = id.firstKeyOf(Policy.class).getId(); if (policyId == 0) { builder.setId(policyId); } } @Nonnull @Override PolicyBuilder getBuilder(@Nonnull final InstanceIdentifier<Policy> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final PolicyBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<PolicyKey> getAllIds(@Nonnull final InstanceIdentifier<Policy> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Policy> readData); @Override Initialized<Policy> init( @Nonnull final InstanceIdentifier<Policy> id, @Nonnull final Policy readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadDefault() throws ReadFailedException { final PolicyBuilder builder = mock(PolicyBuilder.class); getCustomizer().readCurrentAttributes(getId(DEFAULT_POLICY_ID), builder, ctx); verify(builder).setId(DEFAULT_POLICY_ID); } @Test public void testReadNonDefault() throws ReadFailedException { final PolicyBuilder builder = mock(PolicyBuilder.class); getCustomizer().readCurrentAttributes(getId(1L), builder, ctx); verifyZeroInteractions(builder); }
MappingEntryCustomizer implements Ipv4Translator, Ipv6Translator, InitializingListReaderCustomizer<MappingEntry, MappingEntryKey, MappingEntryBuilder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntryBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.trace("Reading current attributes for mapping-entry: {}", id); final int idx = id.firstKeyOf(MappingEntry.class).getIndex().intValue(); final int natInstanceId = id.firstKeyOf(Instance.class).getId().intValue(); final List<Nat44StaticMappingDetails> nat44Details = nat44DumpManager.getDump(id, ctx.getModificationCache()) .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails; final Optional<Nat44StaticMappingDetails> nat44StaticMappingDetails = mappingEntryContext.findDetailsNat44(nat44Details, natInstanceId, idx, ctx.getMappingContext()); if (nat44StaticMappingDetails.isPresent()) { readNat44Entry(builder, idx, nat44StaticMappingDetails.get()); } else { final List<Nat64BibDetails> nat64Details = nat64DumpManager.getDump(id, ctx.getModificationCache()) .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails; final Optional<Nat64BibDetails> nat64StaticMappingDetails = mappingEntryContext.findDetailsNat64(nat64Details, natInstanceId, idx, ctx.getMappingContext()); if (nat64StaticMappingDetails.isPresent()) { readNat64Entry(builder, idx, nat64StaticMappingDetails.get()); } } LOG.trace("Mapping-entry read as: {}", builder); } MappingEntryCustomizer( final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager, final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager, final MappingEntryContext mappingEntryContext); @Nonnull @Override MappingEntryBuilder getBuilder(@Nonnull final InstanceIdentifier<MappingEntry> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntryBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<MappingEntryKey> getAllIds(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<MappingEntry> readData); @Override Initialized<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev180628.nat.instances.instance.mapping.table.MappingEntry> init( @Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadNat44() throws Exception { final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty(); when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat44); stubFindDetailsNat44(dumpNat44, 2); final MappingEntryBuilder builder = new MappingEntryBuilder(); getCustomizer().readCurrentAttributes(mappingEntryId, builder, ctx); assertEquals(NAT_MAPPING_ID, builder.getIndex().longValue()); assertEquals("192.168.3.8/32", builder.getExternalSrcAddress().getIpv4Prefix().getValue()); assertEquals(6874, builder.getExternalSrcPort().getStartPortNumber().getValue().intValue()); assertEquals("192.168.2.2/32", builder.getInternalSrcAddress().getIpv4Prefix().getValue()); assertEquals(1274, builder.getInternalSrcPort().getStartPortNumber().getValue().intValue()); } @Test public void testReadNat44HighPorts() throws Exception { final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty(); when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat44); stubFindDetailsNat44(dumpNat44, 1); final MappingEntryBuilder builder = new MappingEntryBuilder(); getCustomizer().readCurrentAttributes(mappingEntryId, builder, ctx); assertEquals(65535, builder.getExternalSrcPort().getStartPortNumber().getValue().intValue()); assertEquals(60000, builder.getInternalSrcPort().getStartPortNumber().getValue().intValue()); } @Test public void testReadNat64() throws Exception { when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(new Nat44StaticMappingDetailsReplyDump()); final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty(); when(nat64DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat64); stubFindDetailsNat64(dumpNat64, 2); final MappingEntryBuilder builder = new MappingEntryBuilder(); getCustomizer().readCurrentAttributes(mappingEntryId, builder, ctx); assertEquals(NAT_MAPPING_ID, builder.getIndex().longValue()); assertEquals("192.168.64.3/32", builder.getExternalSrcAddress().getIpv4Prefix().getValue()); assertEquals(6874, builder.getExternalSrcPort().getStartPortNumber().getValue().intValue()); assertEquals("2001:db8:85a3::8a2e:370:7303/128", builder.getInternalSrcAddress().getIpv6Prefix().getValue()); assertEquals(1274, builder.getInternalSrcPort().getStartPortNumber().getValue().intValue()); } @Test public void testReadNat64HighPorts() throws Exception { when(nat44DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(new Nat44StaticMappingDetailsReplyDump()); final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty(); when(nat64DumpExecutor.executeDump(mappingEntryId, null)).thenReturn(dumpNat64); stubFindDetailsNat64(dumpNat64, 1); final MappingEntryBuilder builder = new MappingEntryBuilder(); getCustomizer().readCurrentAttributes(mappingEntryId, builder, ctx); assertEquals(65535, builder.getExternalSrcPort().getStartPortNumber().getValue().intValue()); assertEquals(60000, builder.getInternalSrcPort().getStartPortNumber().getValue().intValue()); }
MappingEntryCustomizer implements Ipv4Translator, Ipv6Translator, InitializingListReaderCustomizer<MappingEntry, MappingEntryKey, MappingEntryBuilder> { @Nonnull @Override public List<MappingEntryKey> getAllIds(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final ReadContext context) throws ReadFailedException { final Long natInstanceId = id.firstKeyOf(Instance.class).getId(); LOG.trace("Listing IDs for all mapping-entries within nat-instance(vrf):{}", natInstanceId); final List<MappingEntryKey> entryKeys = nat44DumpManager.getDump(id, context.getModificationCache()) .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream() .filter(detail -> natInstanceId == detail.vrfId) .map(detail -> mappingEntryContext .getStoredOrArtificialIndex(natInstanceId, detail, context.getMappingContext())) .map(MappingEntryKey::new) .collect(Collectors.toList()); final List<MappingEntryKey> nat64Keys = nat64DumpManager.getDump(id, context.getModificationCache()) .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream() .filter(detail -> natInstanceId == detail.vrfId) .map(detail -> mappingEntryContext .getStoredOrArtificialIndex(natInstanceId, detail, context.getMappingContext())) .map(MappingEntryKey::new) .collect(Collectors.toList()); entryKeys.addAll(nat64Keys); LOG.debug("List of mapping-entry keys within nat-instance(vrf):{} : {}", natInstanceId, entryKeys); return entryKeys; } MappingEntryCustomizer( final DumpCacheManager<Nat44StaticMappingDetailsReplyDump, Void> nat44DumpManager, final DumpCacheManager<Nat64BibDetailsReplyDump, Void> nat64DumpManager, final MappingEntryContext mappingEntryContext); @Nonnull @Override MappingEntryBuilder getBuilder(@Nonnull final InstanceIdentifier<MappingEntry> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntryBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<MappingEntryKey> getAllIds(@Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<MappingEntry> readData); @Override Initialized<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev180628.nat.instances.instance.mapping.table.MappingEntry> init( @Nonnull final InstanceIdentifier<MappingEntry> id, @Nonnull final MappingEntry readValue, @Nonnull final ReadContext ctx); }
@Test public void testReadAllNat44() throws Exception { final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty(); when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat44); when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(new Nat64BibDetailsReplyDump()); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L); final List<MappingEntryKey> allIds = getCustomizer().getAllIds(mappingEntryWildcarded, ctx); assertThat(allIds, hasItems(new MappingEntryKey(0L), new MappingEntryKey(2L))); } @Test public void testReadAllNat64() throws Exception { final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty(); when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null)) .thenReturn(new Nat44StaticMappingDetailsReplyDump()); when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat64); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(0), ctx.getMappingContext())).thenReturn(0L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(1), ctx.getMappingContext())).thenReturn(1L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(2), ctx.getMappingContext())).thenReturn(2L); final List<MappingEntryKey> allIds = getCustomizer().getAllIds(mappingEntryWildcarded, ctx); assertThat(allIds, hasItems(new MappingEntryKey(0L), new MappingEntryKey(2L))); } @Test public void testReadAll() throws Exception { final Nat44StaticMappingDetailsReplyDump dumpNat44 = dumpReplyNat44NonEmpty(); final Nat64BibDetailsReplyDump dumpNat64 = dumpReplyNat64NonEmpty(); when(nat44DumpExecutor.executeDump(mappingEntryWildcarded, null)) .thenReturn(dumpNat44); when(nat64DumpExecutor.executeDump(mappingEntryWildcarded, null)).thenReturn(dumpNat64); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(0), ctx.getMappingContext())).thenReturn(0L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(1), ctx.getMappingContext())).thenReturn(1L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat44.nat44StaticMappingDetails.get(2), ctx.getMappingContext())).thenReturn(2L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(0), ctx.getMappingContext())).thenReturn(3L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(1), ctx.getMappingContext())).thenReturn(4L); when(mappingContext.getStoredOrArtificialIndex(NatInstanceCustomizer.DEFAULT_VRF_ID.getId(), dumpNat64.nat64BibDetails.get(2), ctx.getMappingContext())).thenReturn(5L); final List<MappingEntryKey> allIds = getCustomizer().getAllIds(mappingEntryWildcarded, ctx); assertThat(allIds, hasItems(new MappingEntryKey(0L), new MappingEntryKey(2L), new MappingEntryKey(3L), new MappingEntryKey(5L))); }
MplsInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer, ByteDataTranslator { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = ifc.getName(); final int swIfIndex = ifcContext.getIndex(swIfName, writeContext.getMappingContext()); checkArgument(ifc.getConfig() != null, "MPLS interface configuration missing"); final Boolean enabled = ifc.getConfig().isEnabled(); LOG.debug("Configuring MPLS on interface {}(id={}): enabled={}", swIfName, swIfIndex, enabled); createDefaultMplsTable(id); setInterfaceMplsState(id, swIfName, swIfIndex, enabled); LOG.debug("MPLS successfully configured on interface {}(id={})", swIfName, swIfIndex); } MplsInterfaceCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext ifcContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); }
@Test public void testWrite() throws WriteFailedException { customizer.writeCurrentAttributes(IID, MPLS_ENABLED, writeContext); verify(jvpp).mplsTableAddDel(getMplsTableRequest()); verify(jvpp).swInterfaceSetMplsEnable(getInterfaceMplsRequest(true)); }
MplsInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer, ByteDataTranslator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { writeCurrentAttributes(id, dataAfter, writeContext); } MplsInterfaceCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext ifcContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); }
@Test public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(IID, MPLS_ENABLED, MPLS_DISABLED, writeContext); verify(jvpp).mplsTableAddDel(getMplsTableRequest()); verify(jvpp).swInterfaceSetMplsEnable(getInterfaceMplsRequest(false)); }
MplsInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer, ByteDataTranslator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = ifc.getName(); final int swIfIndex = ifcContext.getIndex(swIfName, writeContext.getMappingContext()); LOG.debug("Disabling MPLS on interface {}(id={})", swIfName, swIfIndex); setInterfaceMplsState(id, swIfName, swIfIndex, false); LOG.debug("MPLS successfully disabled on interface {}(id={})", swIfName, swIfIndex); } MplsInterfaceCustomizer(@Nonnull final FutureJVppCore vppApi, @Nonnull final NamingContext ifcContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface ifc, @Nonnull final WriteContext writeContext); }
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, MPLS_ENABLED, writeContext); verify(jvpp).swInterfaceSetMplsEnable(getInterfaceMplsRequest(false)); }
Ipv6RouteCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Route, RouteKey>, JvppReplyConsumer, RouteMapper { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String parentProtocolName = instanceIdentifier.firstKeyOf(ControlPlaneProtocol.class).getName(); final String routeName = namesFactory.uniqueRouteName(parentProtocolName, route); writeRoute(instanceIdentifier, parentProtocolName, routeName, route, writeContext, false); routesContext.removeName(routeName, writeContext.getMappingContext()); } Ipv6RouteCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext, @Nonnull final NamingContext routesContext, @Nonnull final NamingContext routingProtocolContext, @Nonnull final MultiNamingContext routesHopsContext, @Nonnull final VppClassifierContextManager classifierContextManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route route, @Nonnull final WriteContext writeContext); }
@Test public void testDeleteSpecialHop( @InjectTestData(resourcePath = "/ipv6/specialhop/specialHopRouteBlackhole.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.deleteCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(1, ImmutableList .of(desiredSpecialResult(0, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, 1, 0, 0, 0, TABLE_ID.intValue(), 0)), api, requestCaptor); } @Test public void testDeleteSingleHop( @InjectTestData(resourcePath = "/ipv6/simplehop/simpleHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.deleteCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(1, ImmutableList .of(desiredFlaglessResult(0, 1, 0, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 0, 1, 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); } @Test public void testDeleteHopList( @InjectTestData(resourcePath = "/ipv6/multihop/multiHopRouteWithClassifier.json", id = STATIC_ROUTE_PATH) StaticRoutes route) throws WriteFailedException { whenAddRouteThenSuccess(api); customizer.deleteCurrentAttributes(ROUTE_IID, getIpv6RouteWithId(route, IPV_6_PREFIX), writeContext); verifyInvocation(2, ImmutableList.of( desiredFlaglessResult(0, 1, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 2, 1, 0, CLASSIFY_TABLE_INDEX, 1), desiredFlaglessResult(0, 1, 1, Ipv6RouteData.FIRST_ADDRESS_AS_ARRAY, 64, Ipv6RouteData.SECOND_ADDRESS_AS_ARRAY, INTERFACE_INDEX, 2, 1, 0, CLASSIFY_TABLE_INDEX, 1)), api, requestCaptor); }
AclProviderImpl implements AclProvider { @Override public AclAddReplace next() { final AclAddReplace result = acls[currentAcl]; currentAcl = (currentAcl + 1) % aclSetSize; return result; } AclProviderImpl(final int aclSetSize, final int aclSize); @Override AclAddReplace next(); @Override void setAclIndex(final int index); }
@Test public void testAclsDiffer() throws Exception { final AclProviderImpl aclProvider = new AclProviderImpl(2, 2); final AclAddReplace acl0 = aclProvider.next(); final AclAddReplace acl1 = aclProvider.next(); final AclAddReplace acl2 = aclProvider.next(); final AclAddReplace acl3 = aclProvider.next(); assertEquals("ACLs 0 and 2 should be equal", acl0, acl2); assertEquals("ACLs 1 and 3 should be equal", acl1, acl3); assertNotEquals("ACLs 0 and 1 should be different", acl0, acl1); } @Test public void testRulesDiffer() throws Exception { final int aclSize = 3; final AclProviderImpl aclProvider = new AclProviderImpl(1, aclSize); final AclAddReplace acl = aclProvider.next(); assertEquals("Unexpected value of AclAddReplace.count", aclSize, acl.count); assertEquals("Unexpected size of ACL", aclSize, acl.r.length); assertNotEquals("ACL rules 0 and 1 should be different", acl.r[0], acl.r[1]); assertNotEquals("ACL rules 1 and 2 should be different", acl.r[1], acl.r[2]); assertNotEquals("ACL rules 0 and 2 should be different", acl.r[0], acl.r[2]); } @Test public void testIPsWithinRuleDiffer() throws Exception { final AclProviderImpl aclProvider = new AclProviderImpl(1, 1); final AclAddReplace acl = aclProvider.next(); assertFalse(Arrays.equals(acl.r[0].srcIpAddr, acl.r[0].dstIpAddr)); }
ClassifyTableProviderImpl implements ClassifyTableProvider { @Override public ClassifyAddDelTable next() { final ClassifyAddDelTable result = tables[currentTable]; currentTable = (currentTable + 1) % tableSetSize; return result; } ClassifyTableProviderImpl(final int tableSetSize); @Override ClassifyAddDelTable next(); }
@Test public void testTablesDiffer() throws Exception { final ClassifyTableProviderImpl provider = new ClassifyTableProviderImpl(2); final ClassifyAddDelTable table0 = provider.next(); final ClassifyAddDelTable table1 = provider.next(); final ClassifyAddDelTable table2 = provider.next(); final ClassifyAddDelTable table3 = provider.next(); assertEquals("Tables 0 and 2 should be equal", table0, table2); assertEquals("Tables 1 and 3 should be equal", table1, table3); assertNotEquals("Tables 0 and 1 should be different", table0, table1); }
L2FibEntryCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<L2FibEntry, L2FibEntryKey, L2FibEntryBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntryBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final L2FibEntryKey key = id.firstKeyOf(id.getTargetType()); final BridgeDomainKey bridgeDomainKey = id.firstKeyOf(BridgeDomain.class); final int bdId = bdContext.getIndex(bridgeDomainKey.getName(), ctx.getMappingContext()); LOG.debug("Reading L2 FIB entry: key={}. bridgeDomainKey={}, bdId={}", key, bridgeDomainKey, bdId); try { final L2FibTableDetails entry = dumpL2Fibs(id, bdId).stream().filter(e -> key.getPhysAddress() .equals(new PhysAddress(vppPhysAddrToYang((e.mac))))) .collect(SINGLE_ITEM_COLLECTOR); builder.setAction(byteToBoolean(entry.filterMac) ? L2FibFilter.class : L2FibForward.class); builder.setBridgedVirtualInterface(byteToBoolean(entry.bviMac)); if (entry.swIfIndex != -1) { builder.setOutgoingInterface(interfaceContext.getName(entry.swIfIndex, ctx.getMappingContext())); } builder.setStaticConfig(byteToBoolean(entry.staticMac)); builder.setPhysAddress(key.getPhysAddress()); builder.withKey(key); } catch (Exception e) { throw new ReadFailedException(id, e); } } L2FibEntryCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext bdContext, @Nonnull final NamingContext interfaceContext); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntryBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<L2FibEntryKey> getAllIds(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<L2FibEntry> readData); @Nonnull @Override L2FibEntryBuilder getBuilder(@Nonnull final InstanceIdentifier<L2FibEntry> id); @Override Initialized<L2FibEntry> init( @Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry readValue, @Nonnull final ReadContext ctx); }
@Test public void testRead() throws Exception { final byte[] address_vpp = new byte[]{1, 2, 3, 4, 5, 6}; final PhysAddress address = new PhysAddress("01:02:03:04:05:06"); defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME); whenL2FibTableDumpThenReturn(Collections.singletonList(generateL2FibEntry(address_vpp))); final L2FibEntryBuilder builder = mock(L2FibEntryBuilder.class); getCustomizer().readCurrentAttributes(getL2FibEntryId(BD_NAME, address), builder, ctx); verify(builder).setAction(L2FibForward.class); verify(builder).setBridgedVirtualInterface(false); verify(builder).setOutgoingInterface(IFACE_NAME); verify(builder).setStaticConfig(false); verify(builder).setPhysAddress(address); verify(builder).withKey(new L2FibEntryKey(address)); }
L2FibEntryCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<L2FibEntry, L2FibEntryKey, L2FibEntryBuilder>, ByteDataTranslator, InterfaceDataTranslator { @Nonnull @Override public List<L2FibEntryKey> getAllIds(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final BridgeDomainKey bridgeDomainKey = id.firstKeyOf(BridgeDomain.class); final int bdId = bdContext.getIndex(bridgeDomainKey.getName(), ctx.getMappingContext()); LOG.debug("Reading L2 FIB for bridge domain {} (bdId={})", bridgeDomainKey, bdId); return dumpL2Fibs(id, bdId).stream() .map(entry -> new L2FibEntryKey(new PhysAddress(vppPhysAddrToYang(entry.mac)))) .collect(Collectors.toList()); } L2FibEntryCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext bdContext, @Nonnull final NamingContext interfaceContext); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntryBuilder builder, @Nonnull final ReadContext ctx); @Nonnull @Override List<L2FibEntryKey> getAllIds(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<L2FibEntry> readData); @Nonnull @Override L2FibEntryBuilder getBuilder(@Nonnull final InstanceIdentifier<L2FibEntry> id); @Override Initialized<L2FibEntry> init( @Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry readValue, @Nonnull final ReadContext ctx); }
@Test public void testGetAllIds() throws Exception { final byte[] address_vpp = new byte[]{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; final PhysAddress address = new PhysAddress("11:22:33:44:55:66"); whenL2FibTableDumpThenReturn(Collections.singletonList(generateL2FibEntry(address_vpp))); final List<L2FibEntryKey> ids = getCustomizer().getAllIds(getL2FibEntryId(BD_NAME, address), ctx); assertEquals(1, ids.size()); assertEquals(address, ids.get(0).getPhysAddress()); }
SubInterfaceUtils { public static String getSubInterfaceName(final String superIfName, final int subIfaceId) { return String.format("%s.%d", superIfName, subIfaceId); } private SubInterfaceUtils(); static String getSubInterfaceName(final String superIfName, final int subIfaceId); static String subInterfaceFullNameConfig(final @Nonnull InstanceIdentifier<?> instanceIdentifier); static String subInterfaceFullNameOperational(final @Nonnull InstanceIdentifier<?> instanceIdentifier); @Nonnegative static int getNumberOfTags(@Nullable final Tags tags); }
@Test public void testGetSubInterfaceName() throws Exception { final String superIfName = "GigabitEthernet0/9/0"; final int subIfaceId = 123; final String expectedSubIfaceName = "GigabitEthernet0/9/0.123"; assertEquals(expectedSubIfaceName, SubInterfaceUtils.getSubInterfaceName(superIfName, subIfaceId)); }
SubInterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext) throws WriteFailedException { setRouting(instanceIdentifier, subInterfaceFullNameConfig(instanceIdentifier), routing, writeContext); } SubInterfaceRoutingCustomizer(@Nonnull final FutureJVppCore futureJVppCore, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final Routing d1, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> instanceIdentifier, @Nonnull final Routing routing, @Nonnull final WriteContext writeContext); }
@Test public void testWriteIpv4Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build(); customizer.writeCurrentAttributes(VALID_ID, v4Routing, writeContext); verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, 4))); } @Test public void testWriteIpv6Vrf() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); final Routing v6Routing = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)).build(); customizer.writeCurrentAttributes(VALID_ID, v6Routing, writeContext); verifySetTableRequest(1, Collections.singleton(request(true, SUBIF_INDEX, 3))); }