Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testUpdateFailed() throws Exception { final WriteFailedException.UpdateFailedException cause = new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter); final WriteFailedException.UpdateFailedException createFailedException = new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getDataBefore(), dataBefore); assertEquals(createFailedException.getDataAfter(), dataAfter); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to update")); }
@Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); @Nonnull InstanceIdentifier<?> getFailedId(); }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); @Nonnull InstanceIdentifier<?> getFailedId(); }
@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); }
@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 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 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); }
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(); }
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 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()); }
@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 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 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); }
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(); }
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 testMerge() { ctx.merge(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, id, data); }
@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 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 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); }
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(); }
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(expected = IllegalStateException.class) public void testMergeFailure() throws Exception { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.merge(id, data); }
@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 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 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); }
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(); }
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 testPut() { ctx.put(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, id, data); }
@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 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 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); }
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(); }
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(expected = IllegalStateException.class) public void testPutFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.put(id, data); }
@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 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 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); }
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(); }
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 testDelete() { ctx.delete(id); verify(broker).newWriteOnlyTransaction(); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); }
@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 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 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); }
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(); }
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(expected = IllegalStateException.class) public void testDeleteFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.delete(id); }
@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 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 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); }
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(); }
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 testAddVertex() { dag.addVertex(VERTEX_A); final Iterator<InstanceIdentifier<?>> it = dag.iterator(); assertEquals(VERTEX_A, it.next()); assertFalse(it.hasNext()); }
public void addVertex(final InstanceIdentifier<?> vertex) { dag.addVertex(vertex); }
YangDAG { public void addVertex(final InstanceIdentifier<?> vertex) { dag.addVertex(vertex); } }
YangDAG { public void addVertex(final InstanceIdentifier<?> vertex) { dag.addVertex(vertex); } }
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(); }
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 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()); }
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); } }
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); } } }
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); } } }
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(); }
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 testDeleteFailed() throws Exception { final WriteFailedException.DeleteFailedException cause = new WriteFailedException.DeleteFailedException(id); final WriteFailedException.DeleteFailedException createFailedException = new WriteFailedException.DeleteFailedException(id, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to delete")); }
@Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); @Nonnull InstanceIdentifier<?> getFailedId(); }
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message, @Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Throwable cause); @Nonnull InstanceIdentifier<?> getFailedId(); }
@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); }
@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 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 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); }
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(); }
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 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)); }
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(); }
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(); } }
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(); }
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); }
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 testRestore() throws Exception { final ContainerNode normalizedNodeOptional = JsonUtils .readJsonRoot(schemaContext, getClass().getResourceAsStream("/expected-persisted-output.txt")); assertEquals(getData("testing"), normalizedNodeOptional); }
public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); }
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } }
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } private JsonUtils(); }
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); }
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(expected = IllegalArgumentException.class) public void testRestoreInvalidFile() throws Exception { JsonUtils.readJsonRoot(schemaContext, getClass().getResourceAsStream("/test-persistence.yang")); }
public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); }
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } }
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } private JsonUtils(); }
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); }
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(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(); }
@Override public void close() { scheduledFuture.cancel(false); }
KeepaliveReaderWrapper implements DelegatingReader<D, B>,Runnable, Closeable { @Override public void close() { scheduledFuture.cancel(false); } }
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); }
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(); }
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 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()); }
@Override public void close() { scheduledFuture.cancel(false); }
KeepaliveReaderWrapper implements DelegatingReader<D, B>,Runnable, Closeable { @Override public void close() { scheduledFuture.cancel(false); } }
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); }
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(); }
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 public void createKeyBothKeyedComplex() { final String key = complexKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifyComplexKey(key, NO_PARAMS_KEY); }
@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 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 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); }
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(); }
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 createKeyBothKeyedComplexWithParams() { final String key = complexIntegerKeyFactory.createKey(identifierBothKeyed, 123); verifyComplexKey(key, "123"); }
@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 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 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); }
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(); }
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(expected = IllegalArgumentException.class) public void createKeyOneMissingComplex() { complexKeyFactory.createKey(identifierOneMissing, NO_PARAMS); }
@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 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 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); }
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(); }
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(expected = IllegalArgumentException.class) public void createKeyNoneKeyedComplex() { complexKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); }
@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 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 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); }
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(); }
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 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()); }
private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter) { this.id = checkNotNull(id); this.dataAfter = dataAfter; this.dataBefore = dataBefore; }
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; } }
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); }
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(); }
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 createKeyBothKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifySimpleKey(key); }
@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 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 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); }
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(); }
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 createKeyOneMissingSimple() { final String key = simpleKeyFactory.createKey(identifierOneMissing, NO_PARAMS); verifySimpleKey(key); }
@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 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 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); }
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(); }
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 createKeyNoneKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); verifySimpleKey(key); }
@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 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 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); }
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(); }
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 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()); }
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); }
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } }
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); }
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); }
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 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); }
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); }
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } }
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); }
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); }
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 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()); }
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); }
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } }
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); }
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); }
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 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()); }
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); }
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } }
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); }
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); }
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 @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()); }
@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 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 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); }
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); }
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 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)); }
@Nonnull @Override public List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context) throws ReadFailedException { return staticKeys; }
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 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); }
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); }
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 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(); }
@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 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 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); }
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(); }
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 testDataObjectDelete() throws Exception { final DataObjectUpdate dataObjectUpdate = DataObjectUpdate.create(id, first, null); assertTrue(DataObjectUpdate.DataObjectDelete.class.isAssignableFrom(dataObjectUpdate.getClass())); }
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); }
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); } }
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); }
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(); }
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(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); }
@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 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 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); }
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(); }
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(expected = UnsupportedOperationException.class) public void testReadCurrentAttrs() throws Exception { bbReader.readCurrentAttributes(id, new DataObjectBuilder(), ctx); }
@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 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 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); }
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(); }
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 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()); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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(); }
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(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); }
@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 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 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); }
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(); }
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 testMerge() throws Exception { ctx.merge(id, data); verify(writeTx).merge(LogicalDatastoreType.OPERATIONAL, id, data, true); }
@Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, T data) { readWriteTransaction.merge(LogicalDatastoreType.OPERATIONAL, path, data, true); }
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, T data) { readWriteTransaction.merge(LogicalDatastoreType.OPERATIONAL, path, data, true); } }
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); }
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(); }
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 testPut() throws Exception { ctx.put(id, data); verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, id, data, true); }
@Override public <T extends DataObject> void put(final InstanceIdentifier<T> path, T data) { readWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, path, 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 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); }
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(); }
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 testDelete() throws Exception { ctx.delete(id); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); }
@Override public void delete(final InstanceIdentifier<?> path) { readWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, path); }
TransactionMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { readWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, path); } }
TransactionMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { readWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, path); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); }
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(); }
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 testClose() throws Exception { ctx.close(); verify(writeTx).cancel(); }
@Override public void close() { readWriteTransaction.cancel(); }
TransactionMappingContext implements MappingContext { @Override public void close() { readWriteTransaction.cancel(); } }
TransactionMappingContext implements MappingContext { @Override public void close() { readWriteTransaction.cancel(); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); }
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(); }
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 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)); }
public Object get(final Object o) { return map.get(o); }
ModificationCache implements AutoCloseable { public Object get(final Object o) { return map.get(o); } }
ModificationCache implements AutoCloseable { public Object get(final Object o) { return map.get(o); } ModificationCache(); }
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(); }
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 testWrite() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).setIdentifier(BGP.class).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); }
@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 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 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); }
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); }
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(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); }
@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 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 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); }
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); }
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(expected = IllegalArgumentException.class) public void testWriteInvalidProtocolType() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); }
@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 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 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); }
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); }
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(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(Protocol.class), mock(Protocol.class), ctx); }
@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 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 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); }
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); }
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.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(Protocol.class), ctx); }
@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 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 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); }
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); }
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 public void testWrite() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); }
@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 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 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); }
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); }
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(expected = IllegalArgumentException.class) public void testWriteInvalidInstanceName() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName("some-other-name").build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); }
@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 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 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); }
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); }
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(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(NetworkInstance.class), mock(NetworkInstance.class), ctx); }
@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 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 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); }
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); }
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.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(NetworkInstance.class), ctx); }
@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 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 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); }
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); }
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 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(); }
@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 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 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); }
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(); }
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 testPutOper() throws Exception { final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Put, LogicalDatastoreType.OPERATIONAL, jsonReader); init.initialize(); verify(schemaService).getGlobalContext(); verify(jsonReader).readData(schemaContext, path); verify(dataTree).newWriteOnlyTransaction(); verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(nodeId), data); verify(writeTx).commit(); }
@Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } }
RestoringInitializer implements DataTreeInitializer { @Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } } }
RestoringInitializer implements DataTreeInitializer { @Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } } RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType, @Nonnull final JsonReader jsonReader); RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType); }
RestoringInitializer implements DataTreeInitializer { @Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } } RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType, @Nonnull final JsonReader jsonReader); RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType); @Override void initialize(); }
RestoringInitializer implements DataTreeInitializer { @Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } } RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType, @Nonnull final JsonReader jsonReader); RestoringInitializer(@Nonnull final DOMSchemaService schemaService, @Nonnull final Path path, @Nonnull final DOMDataBroker dataTree, @Nonnull final RestorationType restorationType, @Nonnull final LogicalDatastoreType datastoreType); @Override void initialize(); }
@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); }
@Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext) throws WriteFailedException { bindFibTableRequest(table).write(instanceIdentifier); }
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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 containsLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); boolean containsLocator = contextManager.containsLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertTrue(containsLocator); }
@Override public boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name)); return read.isPresent(); }
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 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); }
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); }
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 getLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); Ipv6Prefix locator = contextManager.getLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertEquals(LOCATOR_PREFIX, locator); }
@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 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 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); }
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); }
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 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()); }
@Override public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getLocatorIid(name)); }
LocatorContextManagerImpl implements LocatorContextManager { @Override public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getLocatorIid(name)); } }
LocatorContextManagerImpl implements LocatorContextManager { @Override public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getLocatorIid(name)); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); }
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); }
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 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)); }
@Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceWriteRequest(encapsulation).write(instanceIdentifier); }
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 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); }
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); }
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 deleteCurrentAttributesTest() throws WriteFailedException { sourceCustomizer.deleteCurrentAttributes(Srv6IIds.RT_SRV6_ENCAP, encapsulation, ctx); verify(api, Mockito.times(1)).srSetEncapSource(requestCaptor.capture()); Assert.assertNull(requestCaptor.getValue().encapsSource); }
@Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceDeleteRequest().delete(instanceIdentifier); }
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 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); }
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); }
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(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()); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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))); }
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 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 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); }
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); }
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(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); }
@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.")); }
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.")); } }
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.")); } }
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); }
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 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); }
@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 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 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); }
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); }
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(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); }
@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.")); }
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.")); } }
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.")); } }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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); }
@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 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 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); }
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); }
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 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))); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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::"))); }
@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 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 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); }
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); }
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 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()); }
@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 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 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); }
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); }
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 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))); }
@Nonnull @Override public List<LocatorKey> getAllIds(@Nonnull InstanceIdentifier<Locator> instanceIdentifier, @Nonnull ReadContext readContext) throws ReadFailedException { return new LocatorReadRequest(getFutureJVpp(), locatorContext).readAllKeys(instanceIdentifier, readContext); }
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 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); }
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); }
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 { 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))); }
@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 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 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); }
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); }
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 { 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))); }
@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 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 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); }
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); }
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(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); }
@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 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 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); }
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); }
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 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))); }
@Nonnull @Override public List<PrefixKey> getAllIds(@Nonnull InstanceIdentifier<Prefix> id, @Nonnull ReadContext context) throws ReadFailedException { return new L3SteeringRequest(getFutureJVpp()).readAllKeys(id, context); }
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 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); }
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); }
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 { 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))); }
@Nonnull @Override public List<InterfaceKey> getAllIds(@Nonnull InstanceIdentifier<Interface> id, @Nonnull ReadContext context) throws ReadFailedException { return new L2SteeringRequest(getFutureJVpp(), interfaceContext).readAllKeys(id, context); }
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 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); }
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); }
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(expected = CreateValidationFailedException.class) public void testInvalidPolicyId() throws CreateValidationFailedException { validator.validateWrite(INVALID_POLICY_ID, mock(Policy.class), writeContext); }
@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); } }
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); } } }
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); } } }
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); }
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 public void testNoNat64Prefixes() throws CreateValidationFailedException { validator.validateWrite(DEFAULT_POLICY_ID, mock(Policy.class), writeContext); }
@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); } }
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); } } }
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); } } }
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); }
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 public void testSingleNat64Prefix() throws CreateValidationFailedException { final Policy policy = new PolicyBuilder().setNat64Prefixes(Collections.singletonList(P1)).build(); validator.validateWrite(DEFAULT_POLICY_ID, policy, writeContext); }
@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); } }
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); } } }
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); } } }
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); }
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 testTwoNat64Prefixes() throws CreateValidationFailedException { final Policy policy = new PolicyBuilder().setNat64Prefixes(Arrays.asList(P1, P2)).build(); validator.validateWrite(DEFAULT_POLICY_ID, policy, writeContext); }
@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); } }
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); } } }
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); } } }
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); }
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 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); }
@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); } }
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); } } }
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); } } }
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); }
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(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); }
@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); } }
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); } } }
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); } } }
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); }
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(expected = IllegalArgumentException.class) public void testUnsupportedMappingEntryType() { final MappingEntry mappingEntry = mock(MappingEntry.class); when(mappingEntry.getType()).thenReturn(Type.DynamicExplicit); validator.validateMappingEntryType(mappingEntry); }
@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()); }
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()); } }
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()); } }
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); }
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 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); }
@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); } }
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); } } }
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); } } }
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); }
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); }