Datasets:

jitx
/

Methods2Test_java_unit_test_code

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 624k rows

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 testNotificationTypes() throws Exception { final NotificationProducerRegistry notificationRegistry = new NotificationProducerRegistry(Lists.newArrayList(producer, producer2)); final Set<Class<? extends Notification>> notificationTypes = notificationRegistry.getNotificationTypes(); Assert.assertThat(notificationTypes, hasItem(NetconfSessionEnd.class)); Assert.assertThat(notificationTypes, hasItem(NetconfSessionStart.class)); Assert.assertThat(notificationTypes, hasItem(NetconfCapabilityChange.class)); }	Set<Class<? extends Notification>> getNotificationTypes() { return notificationTypes; }	NotificationProducerRegistry { Set<Class<? extends Notification>> getNotificationTypes() { return notificationTypes; } }	NotificationProducerRegistry { Set<Class<? extends Notification>> getNotificationTypes() { return notificationTypes; } NotificationProducerRegistry(final List<ManagedNotificationProducer> notificationProducersDependency); }	NotificationProducerRegistry { Set<Class<? extends Notification>> getNotificationTypes() { return notificationTypes; } NotificationProducerRegistry(final List<ManagedNotificationProducer> notificationProducersDependency); static QName getQName(final Class<? extends Notification> aClass); }	NotificationProducerRegistry { Set<Class<? extends Notification>> getNotificationTypes() { return notificationTypes; } NotificationProducerRegistry(final List<ManagedNotificationProducer> notificationProducersDependency); static QName getQName(final Class<? extends Notification> aClass); }
@Test public void testTakeSnapshot() throws Exception { persistingDataTreeAdapter.takeSnapshot(); verify(delegatingDataTree).takeSnapshot(); }	@Override public DataTreeSnapshot takeSnapshot() { return delegateDependency.takeSnapshot(); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeSnapshot takeSnapshot() { return delegateDependency.takeSnapshot(); } }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeSnapshot takeSnapshot() { return delegateDependency.takeSnapshot(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeSnapshot takeSnapshot() { return delegateDependency.takeSnapshot(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeSnapshot takeSnapshot() { return delegateDependency.takeSnapshot(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }
@Test public void testSetSchema() throws Exception { persistingDataTreeAdapter.setSchemaContext(null); verify(delegatingDataTree).setSchemaContext(null); }	@Override public void setSchemaContext(final SchemaContext schemaContext) { delegateDependency.setSchemaContext(schemaContext); }	PersistingDataTreeAdapter implements DataTree { @Override public void setSchemaContext(final SchemaContext schemaContext) { delegateDependency.setSchemaContext(schemaContext); } }	PersistingDataTreeAdapter implements DataTree { @Override public void setSchemaContext(final SchemaContext schemaContext) { delegateDependency.setSchemaContext(schemaContext); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); }	PersistingDataTreeAdapter implements DataTree { @Override public void setSchemaContext(final SchemaContext schemaContext) { delegateDependency.setSchemaContext(schemaContext); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public void setSchemaContext(final SchemaContext schemaContext) { delegateDependency.setSchemaContext(schemaContext); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }
@Test public void testValidate() throws Exception { persistingDataTreeAdapter.validate(null); verify(delegatingDataTree).validate(null); }	@Override public void validate(final DataTreeModification dataTreeModification) throws DataValidationFailedException { delegateDependency.validate(dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public void validate(final DataTreeModification dataTreeModification) throws DataValidationFailedException { delegateDependency.validate(dataTreeModification); } }	PersistingDataTreeAdapter implements DataTree { @Override public void validate(final DataTreeModification dataTreeModification) throws DataValidationFailedException { delegateDependency.validate(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); }	PersistingDataTreeAdapter implements DataTree { @Override public void validate(final DataTreeModification dataTreeModification) throws DataValidationFailedException { delegateDependency.validate(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public void validate(final DataTreeModification dataTreeModification) throws DataValidationFailedException { delegateDependency.validate(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }
@Test public void testPrepare() throws Exception { persistingDataTreeAdapter.prepare(null); verify(delegatingDataTree).prepare(null); }	@Override public DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification) { return delegateDependency.prepare(dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification) { return delegateDependency.prepare(dataTreeModification); } }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification) { return delegateDependency.prepare(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification) { return delegateDependency.prepare(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification) { return delegateDependency.prepare(dataTreeModification); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }
@Test public void testGetRootPath() throws Exception { persistingDataTreeAdapter.getRootPath(); verify(delegatingDataTree).getRootPath(); }	@Override public YangInstanceIdentifier getRootPath() { return delegateDependency.getRootPath(); }	PersistingDataTreeAdapter implements DataTree { @Override public YangInstanceIdentifier getRootPath() { return delegateDependency.getRootPath(); } }	PersistingDataTreeAdapter implements DataTree { @Override public YangInstanceIdentifier getRootPath() { return delegateDependency.getRootPath(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); }	PersistingDataTreeAdapter implements DataTree { @Override public YangInstanceIdentifier getRootPath() { return delegateDependency.getRootPath(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }	PersistingDataTreeAdapter implements DataTree { @Override public YangInstanceIdentifier getRootPath() { return delegateDependency.getRootPath(); } PersistingDataTreeAdapter(@Nonnull final DataTree delegate, @Nonnull final DOMSchemaService schemaService, @Nonnull final Path persistPath); PersistingDataTreeAdapter(final DataTree delegate, final JsonPersister persister); @Override DataTreeSnapshot takeSnapshot(); @Override void setSchemaContext(final SchemaContext schemaContext); @Override void commit(final DataTreeCandidate dataTreeCandidate); @Override YangInstanceIdentifier getRootPath(); @Override void validate(final DataTreeModification dataTreeModification); @Override DataTreeCandidateTip prepare( final DataTreeModification dataTreeModification); }
@Test public void testCancel() { readWriteTx.cancel(); verify(writeTx).cancel(); }	@Override public boolean cancel() { delegateReadTx.close(); return delegateWriteTx.cancel(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public boolean cancel() { delegateReadTx.close(); return delegateWriteTx.cancel(); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public boolean cancel() { delegateReadTx.close(); return delegateWriteTx.cancel(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public boolean cancel() { delegateReadTx.close(); return delegateWriteTx.cancel(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public boolean cancel() { delegateReadTx.close(); return delegateWriteTx.cancel(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testPut() { readWriteTx.put(store, path, data); verify(writeTx).put(store, path, data); }	@Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.put(store, path, data); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.put(store, path, data); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.put(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.put(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.put(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testMergeConfig() throws Exception { final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); verify(writeTx).merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create(nodeId), data); }	@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 testMerge() { readWriteTx.merge(store, path, data); verify(writeTx).merge(store, path, data); }	@Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testDelete() { readWriteTx.delete(store, path); verify(writeTx).delete(store, path); }	@Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testCommit() { readWriteTx.commit(); verify(writeTx).commit(); }	@Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testRead() { readWriteTx.read(store, path); verify(readTx).read(store, path); }	@Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testExists() { readWriteTx.exists(store, path); verify(readTx).exists(store, path); }	@Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testGetIdentifier() { assertNotNull(readWriteTx.getIdentifier()); }	@Override public Object getIdentifier() { return this; }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public Object getIdentifier() { return this; } }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public Object getIdentifier() { return this; } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public Object getIdentifier() { return this; } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public Object getIdentifier() { return this; } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testExists() { final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = mock(FluentFuture.class); when(operationalData.read(path)).thenReturn(future); readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, path); verify(operationalData).read(path); }	@Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); } }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }
@Test public void testGetIdentifier() { assertNotNull(readOnlyTx.getIdentifier()); }	@Nonnull @Override public Object getIdentifier() { return this; }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Nonnull @Override public Object getIdentifier() { return this; } }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Nonnull @Override public Object getIdentifier() { return this; } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Nonnull @Override public Object getIdentifier() { return this; } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }	ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Nonnull @Override public Object getIdentifier() { return this; } private ReadOnlyTransaction(@Nullable final DataModification configData, @Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }
@Test public void testRead() throws Exception { final ContainerNode topContainer = getTopContainer("topContainer"); addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID); final FluentFuture<Optional<NormalizedNode<?, ?>>> read = configDataTree.read(TOP_CONTAINER_ID); final FluentFuture<Optional<NormalizedNode<?, ?>>> read2 = configDataTree.newModification().read(TOP_CONTAINER_ID); final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = read.get(); final Optional<NormalizedNode<?, ?>> normalizedNodeOptional2 = read2.get(); assertEquals(normalizedNodeOptional, normalizedNodeOptional2); assertTrue(normalizedNodeOptional.isPresent()); assertEquals(topContainer, normalizedNodeOptional.get()); assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), normalizedNodeOptional); }	@Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }
@Test public void testValidateTwice() throws Exception { final MapNode nestedList = getNestedList("listEntry", "listValue"); final DataModification dataModification = configDataTree.newModification(); dataModification.write(NESTED_LIST_ID, nestedList); dataModification.validate(); dataModification.validate(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> map = HashMultimap.create(); map.put(DEFAULT_ID, DataObjectUpdate.create(DEFAULT_ID, null, DEFAULT_DATA_OBJECT)); final WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates(map, ImmutableMultimap.of()); verify(writer, times(2)).validateModifications(eq(updates), any(WriteContext.class)); }	@Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }
@Test public void testNoRestore() throws Exception { Files.delete(path); final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); verifyZeroInteractions(writeTx); }	@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 testCommitSuccessful() throws Exception { final MapNode nestedList = getNestedList("listEntry", "listValue"); final DataModification dataModification = configDataTree.newModification(); dataModification.write(NESTED_LIST_ID, nestedList); dataModification.validate(); dataModification.commit(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> map = HashMultimap.create(); map.put(DEFAULT_ID, DataObjectUpdate.create(DEFAULT_ID, null, DEFAULT_DATA_OBJECT)); verify(writer).processModifications(eq(new WriterRegistry.DataObjectUpdates(map, ImmutableMultimap.of())), any(WriteContext.class)); assertEquals(nestedList, dataTree.takeSnapshot().readNode(NESTED_LIST_ID).get()); }	@Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }
@Test public void testToBindingAware() throws Exception { when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(null))).thenReturn(null); when(writer.writerSupportsUpdate(any())).thenReturn(true); final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes = new HashMap<>(); final QName nn1 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid1 = mockYid(nn1); final InstanceIdentifier iid1 = mockIid(yid1, DataObject1.class); final NormalizedNode nn1B = mockNormalizedNode(nn1); final DataObject1 do1B = mockDataObject(yid1, iid1, nn1B, DataObject1.class); biNodes.put(yid1, NormalizedNodeUpdate.create(yid1, nn1B, null)); final QName nn2 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid2 = mockYid(nn2); final InstanceIdentifier iid2 = mockIid(yid2, DataObject2.class); final NormalizedNode nn2A = mockNormalizedNode(nn2); final DataObject2 do2A = mockDataObject(yid2, iid2, nn2A, DataObject2.class); biNodes.put(yid2, NormalizedNodeUpdate.create(yid2, null, nn2A)); final QName nn3 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid3 = mockYid(nn3); final InstanceIdentifier iid3 = mockIid(yid3, DataObject3.class); final NormalizedNode nn3B = mockNormalizedNode(nn3); final DataObject3 do3B = mockDataObject(yid3, iid3, nn3B, DataObject3.class); final NormalizedNode nn3A = mockNormalizedNode(nn3); final DataObject3 do3A = mockDataObject(yid3, iid3, nn3A, DataObject3.class); biNodes.put(yid3, NormalizedNodeUpdate.create(yid3, nn3B, nn3A)); final WriterRegistry.DataObjectUpdates dataObjectUpdates = ModifiableDataTreeDelegator.toBindingAware(writer, biNodes, serializer); assertThat(dataObjectUpdates.getDeletes().size(), is(1)); assertThat(dataObjectUpdates.getDeletes().keySet(), hasItem(((InstanceIdentifier<?>) iid1))); assertThat(dataObjectUpdates.getDeletes().values(), hasItem( ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid1, do1B, null)))); assertThat(dataObjectUpdates.getUpdates().size(), is(2)); assertThat(dataObjectUpdates.getUpdates().keySet(), hasItems((InstanceIdentifier<?>) iid2, (InstanceIdentifier<?>) iid3)); assertThat(dataObjectUpdates.getUpdates().values(), hasItems( DataObjectUpdate.create(iid2, null, do2A), DataObjectUpdate.create(iid3, do3B, do3A))); assertThat(dataObjectUpdates.getTypeIntersection().size(), is(3)); }	@VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }
@Test public void testToBindingAwareUpdateNotSupported() throws Exception { when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(null))).thenReturn(null); when(writer.writerSupportsUpdate(any())).thenReturn(false); final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes = new HashMap<>(); final QName nn1 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid1 = mockYid(nn1); final InstanceIdentifier iid1 = mockIid(yid1, DataObject1.class); final NormalizedNode nn1B = mockNormalizedNode(nn1); final DataObject1 do1B = mockDataObject(yid1, iid1, nn1B, DataObject1.class); biNodes.put(yid1, NormalizedNodeUpdate.create(yid1, nn1B, null)); final QName nn2 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid2 = mockYid(nn2); final InstanceIdentifier iid2 = mockIid(yid2, DataObject2.class); final NormalizedNode nn2A = mockNormalizedNode(nn2); final DataObject2 do2A = mockDataObject(yid2, iid2, nn2A, DataObject2.class); biNodes.put(yid2, NormalizedNodeUpdate.create(yid2, null, nn2A)); final QName nn3 = QName.create("namespace", "nn1"); final YangInstanceIdentifier yid3 = mockYid(nn3); final InstanceIdentifier iid3 = mockIid(yid3, DataObject3.class); final NormalizedNode nn3B = mockNormalizedNode(nn3); final DataObject3 do3B = mockDataObject(yid3, iid3, nn3B, DataObject3.class); final NormalizedNode nn3A = mockNormalizedNode(nn3); final DataObject3 do3A = mockDataObject(yid3, iid3, nn3A, DataObject3.class); biNodes.put(yid3, NormalizedNodeUpdate.create(yid3, nn3B, nn3A)); final WriterRegistry.DataObjectUpdates dataObjectUpdates = ModifiableDataTreeDelegator.toBindingAware(writer, biNodes, serializer); assertThat(dataObjectUpdates.getDeletes().size(), is(2)); assertThat(dataObjectUpdates.getDeletes().keySet(), hasItems(((InstanceIdentifier<?>) iid1), (InstanceIdentifier<?>) iid3)); assertThat(dataObjectUpdates.getDeletes().values(), hasItems( ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid1, do1B, null)), ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid3, do3B, null)))); assertThat(dataObjectUpdates.getUpdates().size(), is(2)); assertThat(dataObjectUpdates.getUpdates().keySet(), hasItems((InstanceIdentifier<?>) iid2, (InstanceIdentifier<?>) iid3)); assertThat(dataObjectUpdates.getUpdates().values(), hasItems( DataObjectUpdate.create(iid2, null, do2A), DataObjectUpdate.create(iid3, null, do3A))); assertThat(dataObjectUpdates.getTypeIntersection().size(), is(3)); }	@VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }	ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @VisibleForTesting static WriterRegistry.DataObjectUpdates toBindingAware( final WriterRegistry registry, final Map<YangInstanceIdentifier, NormalizedNodeUpdate> biNodes, final BindingNormalizedNodeSerializer serializer) { final Multimap<InstanceIdentifier<?>, DataObjectUpdate> dataObjectUpdates = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> dataObjectDeletes = HashMultimap.create(); for (Map.Entry<YangInstanceIdentifier, NormalizedNodeUpdate> biEntry : biNodes.entrySet()) { final InstanceIdentifier<?> keyedId = serializer.fromYangInstanceIdentifier(biEntry.getKey()); final InstanceIdentifier<?> unkeyedIid = RWUtils.makeIidWildcarded(keyedId); NormalizedNodeUpdate normalizedNodeUpdate = biEntry.getValue(); final DataObjectUpdate dataObjectUpdate = toDataObjectUpdate(normalizedNodeUpdate, serializer); if (dataObjectUpdate != null) { if (dataObjectUpdate instanceof DataObjectUpdate.DataObjectDelete) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) dataObjectUpdate); } else if (dataObjectUpdate.getDataBefore() != null && !registry.writerSupportsUpdate(unkeyedIid)) { dataObjectDeletes.put(unkeyedIid, (DataObjectUpdate.DataObjectDelete) DataObjectUpdate.DataObjectDelete .create(keyedId, dataObjectUpdate.getDataBefore(), null)); dataObjectUpdates .put(unkeyedIid, DataObjectUpdate.create(keyedId, null, dataObjectUpdate.getDataAfter())); } else { dataObjectUpdates.put(unkeyedIid, dataObjectUpdate); } } } return new WriterRegistry.DataObjectUpdates(dataObjectUpdates, dataObjectDeletes); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final DataTree dataTree, @Nonnull final SchemaContext schema, @Nonnull final WriterRegistry writerRegistry, @Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }
@Test public void testPut() { writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data); verify(configSnapshot).write(path, data); }	@Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test(expected = IllegalArgumentException.class) public void testPutOperational() { writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data); verify(configSnapshot).write(path, data); }	@Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testMerge() { writeTx.merge(LogicalDatastoreType.CONFIGURATION, path, data); verify(configSnapshot).merge(path, data); }	@Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); }	WriteTransaction implements ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); } }	WriteTransaction implements ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testCancel() { assertTrue(writeTx.cancel()); }	@Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } }	WriteTransaction implements ValidableTransaction { @Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } } }	WriteTransaction implements ValidableTransaction { @Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testDelete() { writeTx.delete(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).delete(path); }	@Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); }	WriteTransaction implements ValidableTransaction { @Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); } }	WriteTransaction implements ValidableTransaction { @Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testSubmit() throws Exception { writeTx.commit(); verify(configSnapshot).commit(); }	@Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testSubmitFailed() throws Exception { doThrow(mock(ValidationFailedException.class)).when(configSnapshot).commit(); final FluentFuture<? extends CommitInfo> future = writeTx.commit(); try { future.get(); } catch (Exception e) { assertTrue(e.getCause() instanceof TransactionCommitFailedException); return; } fail("Expected exception to be thrown"); }	@Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test(expected = DataTreeInitializer.InitializeException.class) public void testFail() throws Exception { when(jsonReader.readData(schemaContext, path)).thenThrow(new IOException("t")); final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); }	@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 testCommit() throws TranslationException { writeTx.commit(); verify(configSnapshot).commit(); }	@Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testGetIdentifier() { assertNotNull(writeTx.getIdentifier()); }	@Override public Object getIdentifier() { return this; }	WriteTransaction implements ValidableTransaction { @Override public Object getIdentifier() { return this; } }	WriteTransaction implements ValidableTransaction { @Override public Object getIdentifier() { return this; } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); }	WriteTransaction implements ValidableTransaction { @Override public Object getIdentifier() { return this; } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }	WriteTransaction implements ValidableTransaction { @Override public Object getIdentifier() { return this; } private WriteTransaction(@Nullable final DataModification configModification, @Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }
@Test public void testNewReadWriteTransaction() { final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readWriteTx.read(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).read(path); verify(confiDataTree).newModification(); }	@Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }
@Test public void testNewWriteOnlyTransaction() { broker.newWriteOnlyTransaction(); verify(confiDataTree).newModification(); }	@Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); } }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }
@Test public void testNewReadOnlyTransaction() { final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readTx.read(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).read(path); }	@Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); } }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); } DataBroker(final TransactionFactory transactionFactory); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }
@Test(expected = UnsupportedOperationException.class) public void testCreateTransactionChain() { final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class); broker.createTransactionChain(listener); }	@Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } DataBroker(final TransactionFactory transactionFactory); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }	DataBroker implements DOMDataBroker, Closeable { @Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }
@Test public void testGetSupportedExtensions() { final @NonNull ClassToInstanceMap<DOMDataBrokerExtension> supportedExtensions = broker.getExtensions(); assertEquals(1, supportedExtensions.size()); assertNotNull(supportedExtensions.get(DOMDataTransactionValidator.class)); }	@Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); }	DataBroker implements DOMDataBroker, Closeable { @Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); } }	DataBroker implements DOMDataBroker, Closeable { @Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); } DataBroker(final TransactionFactory transactionFactory); }	DataBroker implements DOMDataBroker, Closeable { @Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }	DataBroker implements DOMDataBroker, Closeable { @Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree, @Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }
@Test public void revertSingle() throws Exception { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); new Reverter(ImmutableList.of(create), registry).revert(writeContext); assertSingleRevert(create); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void revertSingleFailed() throws TranslationException { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); final UpdateFailedException ex = new UpdateFailedException(new IllegalStateException(), Collections.emptyList(), create); doThrow(ex).when(registry) .processModifications(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class)); try { new Reverter(ImmutableList.of(create), registry).revert(writeContext); } catch (Reverter.RevertFailedException e) { assertEquals(ex, e.getCause()); assertSingleRevert(create); return; } fail("Reverter.RevertFailedException was expected"); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void revertSingleFailedWithUnexpectedEx() throws TranslationException { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); final IllegalStateException ex = new IllegalStateException(); doThrow(ex).when(registry) .processModifications(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class)); try { new Reverter(ImmutableList.of(create), registry).revert(writeContext); } catch (Reverter.RevertFailedException e) { assertEquals(ex, e.getCause()); assertSingleRevert(create); return; } fail("IllegalStateException was expected"); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void testRelationsBefore() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject3.class)); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject4.class)); flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject2.class), Lists.newArrayList(DataObjects.DataObject3.IID, DataObjects.DataObject4.IID)); flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject1.IID, typesInList.get(0)); assertEquals(DataObjects.DataObject2.IID, typesInList.get(1)); assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); }	@VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }
@Test public void revertMultiple() throws Exception { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); final DataObjectUpdate update = DataObjectUpdate.create(IID_1, mock(DataObject1.class), mock(DataObject1.class)); final DataObjectUpdate delete = DataObjectUpdate.create(IID_2, mock(DataObject2.class), null); new Reverter(ImmutableList.of(create, update, delete), registry).revert(writeContext); assertMultiRevert(create, update, delete); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void revertMultipleFailed() throws Exception { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); final DataObjectUpdate update = DataObjectUpdate.create(IID_1, mock(DataObject1.class), mock(DataObject1.class)); final DataObjectUpdate delete = DataObjectUpdate.create(IID_2, mock(DataObject2.class), null); final UpdateFailedException ex = new UpdateFailedException(new IllegalStateException(), ImmutableList.of(create, update), create); doThrow(ex).when(registry) .processModifications(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class)); try { new Reverter(ImmutableList.of(create, update, delete), registry).revert(writeContext); } catch (Reverter.RevertFailedException e) { assertEquals(ex, e.getCause()); assertMultiRevert(create, update, delete); return; } fail("Reverter.RevertFailedException was expected"); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void revertMultipleFailedWithUnnexpectedException() throws Exception { final DataObjectUpdate create = DataObjectUpdate.create(IID_0, null, mock(DataObject.class)); final DataObjectUpdate update = DataObjectUpdate.create(IID_1, mock(DataObject1.class), mock(DataObject1.class)); final DataObjectUpdate delete = DataObjectUpdate.create(IID_2, mock(DataObject2.class), null); final IllegalStateException ex = new IllegalStateException(); doThrow(ex).when(registry) .processModifications(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class)); try { new Reverter(ImmutableList.of(create, update, delete), registry).revert(writeContext); } catch (Reverter.RevertFailedException e) { assertEquals(ex, e.getCause()); assertMultiRevert(create, update, delete); return; } fail("IllegalStateException was expected"); }	void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }	Reverter { void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException { checkNotNull(writeContext, "Cannot revert changes for null context"); final WriterRegistry.DataObjectUpdates revertedAndMapped = revertAndMapProcessed(revertOrder(toBeReverted)); LOG.info("Attempting revert for changes: {}", revertedAndMapped); try { writerRegistry.processModifications(revertedAndMapped, writeContext); LOG.info("Revert successful"); } catch (UpdateFailedException e) { LOG.error("Revert failed", e); final Set<DataObjectUpdate> nonReverted = revertedAndMapped.getAllModifications(); nonReverted.removeAll(e.getProcessed()); throw new RevertFailedException(e.getFailed(), nonReverted, e); } catch (Exception e) { LOG.error("Revert failed with unexpected error"); throw new RevertFailedException(e); } } Reverter(final List<DataObjectUpdate> toBeReverted, final WriterRegistry writerRegistry); }
@Test public void testReadNode() throws Exception { final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class); final YangInstanceIdentifier.PathArgument pArg = mock(YangInstanceIdentifier.PathArgument.class); doReturn(pArg).when(yangId).getLastPathArgument(); doReturn(Collections.singletonList(pArg)).when(yangId).getPathArguments(); doReturn(QName.create("namespace", "2012-12-12", "local")).when(pArg).getNodeType(); doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId); final DataObject dataObject = mock(DataObject.class); doReturn(Optional.of(dataObject)).when(reader).read(same(id), any(ReadContext.class)); when(serializer.toNormalizedNode(id, dataObject)).thenReturn(entry); final DataContainerChild<?, ?> expectedValue = mock(DataContainerChild.class); doReturn(expectedValue).when(entry).getValue(); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(yangId); verify(serializer).fromYangInstanceIdentifier(yangId); verify(reader).read(same(id), any(ReadContext.class)); final Optional<NormalizedNode<?, ?>> result = future.get(); assertTrue(result.isPresent()); assertEquals(expectedValue, result.get()); }	private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } }	ReadableDataTreeDelegator implements ReadableDataManager { private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } } }	ReadableDataTreeDelegator implements ReadableDataManager { private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); }	ReadableDataTreeDelegator implements ReadableDataManager { private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }	ReadableDataTreeDelegator implements ReadableDataManager { private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }
@Test public void testReadNonExistingNode() throws Exception { final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class); doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId); doReturn(Optional.empty()).when(reader).read(same(id), any(ReadContext.class)); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(yangId); verify(serializer).fromYangInstanceIdentifier(yangId); verify(reader).read(same(id), any(ReadContext.class)); final Optional<NormalizedNode<?, ?>> result = future.get(); assertFalse(result.isPresent()); }	@Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }
@Test public void testReadFailed() throws Exception { doThrow(io.fd.honeycomb.translate.read.ReadFailedException.class).when(reader).readAll(any(ReadContext.class)); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(YangInstanceIdentifier.EMPTY); try { future.get(); } catch (ExecutionException e) { assertTrue(e.getCause() instanceof ReadFailedException); return; } fail("ReadFailedException was expected"); }	@Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }
@Test public void testReadRootWithOneNonListElement() throws Exception { final InstanceIdentifier<DataObject> vppStateII = InstanceIdentifier.create(DataObject.class); final DataObject vppState = mock(DataObject.class); Multimap<InstanceIdentifier<?>, DataObject> dataObjects = LinkedListMultimap.create(); dataObjects.put(vppStateII, vppState); doReturn(dataObjects).when(reader).readAll(any(ReadContext.class)); final YangInstanceIdentifier vppYangId = YangInstanceIdentifier.builder().node(QName.create("n", "d")).build(); when(serializer.toYangInstanceIdentifier(vppStateII)).thenReturn(vppYangId); when(serializer.toNormalizedNode(vppStateII, vppState)).thenReturn(entry); final DataContainerChild<?, ?> vppStateContainer = mock(DataContainerChild.class); doReturn(vppStateContainer).when(entry).getValue(); doReturn(vppYangId.getLastPathArgument()).when(vppStateContainer).getIdentifier(); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(YangInstanceIdentifier.EMPTY); verify(reader).readAll(any(ReadContext.class)); verify(serializer).toYangInstanceIdentifier(vppStateII); verify(serializer).toNormalizedNode(vppStateII, vppState); final Optional<NormalizedNode<?, ?>> result = future.get(); assertTrue(result.isPresent()); final ContainerNode rootNode = (ContainerNode) result.get(); assertEquals(SchemaContext.NAME, rootNode.getIdentifier().getNodeType()); assertEquals(vppStateContainer, Iterables.getOnlyElement(rootNode.getValue())); }	@Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }	ReadableDataTreeDelegator implements ReadableDataManager { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { try (TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional<NormalizedNode<?, ?>> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { value = readRoot(ctx); } else { value = readNode(yangInstanceIdentifier, ctx); } final FluentFuture<? extends CommitInfo> contextUpdateResult = ((TransactionMappingContext) ctx.getMappingContext()).commit(); contextUpdateResult.get(); return FluentFutures.immediateFluentFuture(value); } catch (InterruptedException \| ExecutionException \| ReadFailedException ex) { return FluentFutures.immediateFailedFluentFuture( new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", ex)); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }
@Test public void testWrapMixin() throws Exception { final QName nodeQName = QName.create("namespace", "node"); final QName keyQName = QName.create("namespace", "key"); final List<NormalizedNode<?, ?>> mapNodes = Lists.newArrayList("one", "two", "three").stream() .map(value -> ImmutableNodes.mapEntry(nodeQName, keyQName, value)) .collect(Collectors.toList()); final ListSchemaNode listSchema = mock(ListSchemaNode.class); doReturn(Collections.singletonList(keyQName)).when(listSchema).getKeyDefinition(); doReturn(true).when(listSchema).isUserOrdered(); doReturn(nodeQName).when(listSchema).getQName(); final DataContainerChild<?, ?> dataContainerChild = ReadableDataTreeDelegator.wrapListIntoMixinNode(mapNodes, listSchema); assertArrayEquals(mapNodes.toArray(), ((UnmodifiableCollection) dataContainerChild.getValue()).toArray()); }	@VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } }	ReadableDataTreeDelegator implements ReadableDataManager { @VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } } }	ReadableDataTreeDelegator implements ReadableDataManager { @VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); }	ReadableDataTreeDelegator implements ReadableDataManager { @VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }	ReadableDataTreeDelegator implements ReadableDataManager { @VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }
@Test public void testInitialWrite() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> topContainer = getTopContainer("string1"); final YangInstanceIdentifier TOP_CONTAINER_ID = YangInstanceIdentifier.of(TOP_CONTAINER_QNAME); dataTreeModification.write(TOP_CONTAINER_ID, topContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); assertThat(modificationDiff.getUpdates().size(), is(1)); assertThat(modificationDiff.getUpdates().values().size(), is(1)); assertUpdate(modificationDiff.getUpdates().values().iterator().next(), TOP_CONTAINER_ID, null, topContainer); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testLeafList() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final ContainerNode topContainer = getTopContainerWithLeafList("string1", "string2"); final YangInstanceIdentifier TOP_CONTAINER_ID = YangInstanceIdentifier.of(TOP_CONTAINER_QNAME); dataTreeModification.write(TOP_CONTAINER_ID, topContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); assertThat(modificationDiff.getUpdates().size(), is(1)); assertThat(modificationDiff.getUpdates().values().size(), is(1)); assertUpdate(modificationDiff.getUpdates().values().iterator().next(), TOP_CONTAINER_ID.node(FOR_LEAF_LIST_QNAME), null, topContainer.getChild(new YangInstanceIdentifier.NodeIdentifier(FOR_LEAF_LIST_QNAME)).get()); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testBuild() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class); flatWriterRegistryBuilder.add(writer); final WriterRegistry build = flatWriterRegistryBuilder.build(); final InstanceIdentifier<DataObjects.DataObject3> id = InstanceIdentifier.create(DataObjects.DataObject3.class); final DataObjectUpdate update = mock(DataObjectUpdate.class); doReturn(id).when(update).getId(); final DataObjects.DataObject3 before = mock(DataObjects.DataObject3.class); final DataObjects.DataObject3 after = mock(DataObjects.DataObject3.class); when(update.getDataBefore()).thenReturn(before); when(update.getDataAfter()).thenReturn(after); WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates( Multimaps.forMap(Collections.singletonMap(id, update)), Multimaps.forMap(Collections.emptyMap())); final WriteContext ctx = mock(WriteContext.class); build.processModifications(updates, ctx); verify(writer).processModification(id, before, after, ctx); }	@Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }
@Test public void testWritePresenceEmptyContainer() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> presenceContainer = Builders.containerBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(PRESENCE_CONTAINER_QNAME)) .build(); final YangInstanceIdentifier PRESENCE_CONTAINER_ID = YangInstanceIdentifier.of(PRESENCE_CONTAINER_QNAME); dataTreeModification.write(PRESENCE_CONTAINER_ID, presenceContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); dataTree.commit(prepare); final Optional<NormalizedNode<?, ?>> presenceAfter = getModification(dataTree).readNode(PRESENCE_CONTAINER_ID); assertTrue(presenceAfter.isPresent()); assertThat(presenceAfter.get(), equalTo(presenceContainer)); assertThat(modificationDiff.getUpdates().size(), is(1)); assertThat(modificationDiff.getUpdates().values().size(), is(1)); assertUpdate(modificationDiff.getUpdates().values().iterator().next(), PRESENCE_CONTAINER_ID, null, presenceContainer); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testInitialWriteForContainerWithChoice() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final ContainerNode containerWithChoice = Builders.containerBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(WITH_CHOICE_CONTAINER_QNAME)) .withChild(Builders.choiceBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CHOICE_QNAME)) .withChild(ImmutableNodes.leafNode(IN_CASE1_LEAF_QNAME, "withinCase1")) .build()) .build(); final YangInstanceIdentifier WITH_CHOICE_CONTAINER_ID = YangInstanceIdentifier.of(WITH_CHOICE_CONTAINER_QNAME); dataTreeModification.write(WITH_CHOICE_CONTAINER_ID, containerWithChoice); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates = getModificationDiff(prepare).getUpdates(); assertThat(updates.size(), is(1)); assertUpdate(getNormalizedNodeUpdateForAfterType(updates, ContainerNode.class), WITH_CHOICE_CONTAINER_ID, null, containerWithChoice); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testWriteNonPresenceEmptyContainer() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> topContainer = ImmutableNodes.containerNode(TOP_CONTAINER_QNAME); dataTreeModification.write(TOP_CONTAINER_ID, topContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); assertThat(modificationDiff.getUpdates().size(), is(0)); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testWriteNonPresenceNonEmptyContainer() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> topContainer = Builders.containerBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_CONTAINER_QNAME)) .withChild(getNestedList("value","txt")) .build(); dataTreeModification.write(TOP_CONTAINER_ID, topContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); assertThat(modificationDiff.getUpdates().size(), is(1)); assertNodeModificationPresent(modificationDiff, ImmutableSet.of(NESTED_LIST_QNAME)); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testWriteNonPresenceEmptyNestedContainer() throws Exception { final DataTree dataTree = getDataTree(); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> topContainer = Builders.containerBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_CONTAINER_QNAME)) .withChild(ImmutableNodes.containerNode(EMPTY_QNAME)) .withChild(ImmutableNodes.leafNode(STRING_LEAF_QNAME, "1")) .build(); dataTreeModification.write(TOP_CONTAINER_ID, topContainer); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final ModificationDiff modificationDiff = getModificationDiff(prepare); dataTree.commit(prepare); assertThat(modificationDiff.getUpdates().size(), is(1)); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testUpdateWrite() throws Exception { final DataTree dataTree = getDataTree(); final ContainerNode topContainer = getTopContainer("string1"); addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID); final DataTreeModification dataTreeModification = getModification(dataTree); final NormalizedNode<?, ?> topContainerAfter = getTopContainer("string2"); dataTreeModification.write(TOP_CONTAINER_ID, topContainerAfter); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates = getModificationDiff(prepare).getUpdates(); assertThat(updates.size(), is(1)); assertThat(updates.values().size(), is(1)); assertUpdate(updates.values().iterator().next(), TOP_CONTAINER_ID, topContainer, topContainerAfter); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void testUpdateDelete() throws Exception { final DataTree dataTree = getDataTree(); final ContainerNode topContainer = getTopContainer("string1"); addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID); final DataTreeModification dataTreeModification = getModification(dataTree); dataTreeModification.delete(TOP_CONTAINER_ID); final DataTreeCandidateTip prepare = prepareModification(dataTree, dataTreeModification); final Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates = getModificationDiff(prepare).getUpdates(); assertThat(updates.size(), is(1)); assertThat(updates.values().size(), is(1)); assertUpdate(updates.values().iterator().next(), TOP_CONTAINER_ID, topContainer, null); }	Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }	ModificationDiff { Map<YangInstanceIdentifier, NormalizedNodeUpdate> getUpdates() { return updates; } private ModificationDiff(@Nonnull Map<YangInstanceIdentifier, NormalizedNodeUpdate> updates); @Override String toString(); }
@Test public void read() throws Exception { final YangModuleWhitelist whitelist = reader.read( Paths.get(this.getClass().getClassLoader().getResource("expected-whitelist.xml").getPath())); assertNotNull(whitelist); final List<Module> modules = whitelist.getModules(); assertEquals(2, modules.size()); final Module moduleA = new Module(); final Module moduleB = new Module(); moduleA.setPckg("module.a.package"); moduleA.setDescription("desc"); moduleB.setPckg("module.b.package"); assertTrue(modules.containsAll(ImmutableSet.of(moduleA, moduleB))); }	@Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); }	YangModuleWhitelistReader extends JAXBContextHolder { @Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); } }	YangModuleWhitelistReader extends JAXBContextHolder { @Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); } YangModuleWhitelistReader(); }	YangModuleWhitelistReader extends JAXBContextHolder { @Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); } YangModuleWhitelistReader(); @Nonnull YangModuleWhitelist read(@Nonnull final Path path); }	YangModuleWhitelistReader extends JAXBContextHolder { @Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); } YangModuleWhitelistReader(); @Nonnull YangModuleWhitelist read(@Nonnull final Path path); }
@Test public void write() throws Exception { final Module moduleA = new Module(); final Module moduleB = new Module(); moduleA.setPckg("module.a.package"); moduleA.setDescription("desc"); moduleB.setPckg("module.b.package"); final YangModuleWhitelist whitelist = new YangModuleWhitelist(); whitelist.setModules(ImmutableList.of(moduleA, moduleB)); writer.write(whitelist, path, false); final String output = Files.readAllLines(path).stream().collect(Collectors.joining()); final String expectedOutput = Resources .toString(this.getClass().getClassLoader().getResource("expected-whitelist.xml"), StandardCharsets.UTF_8); assertEquals(expectedOutput, output); }	public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); }	YangModuleWhitelistWriter extends JAXBContextHolder { public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); } }	YangModuleWhitelistWriter extends JAXBContextHolder { public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); } YangModuleWhitelistWriter(); }	YangModuleWhitelistWriter extends JAXBContextHolder { public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); } YangModuleWhitelistWriter(); void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput); }	YangModuleWhitelistWriter extends JAXBContextHolder { public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); } YangModuleWhitelistWriter(); void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput); }
@Test(expected = IllegalArgumentException.class) public void testBuildUnknownWriter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class); flatWriterRegistryBuilder.add(writer); final WriterRegistry build = flatWriterRegistryBuilder.build(); final InstanceIdentifier<DataObjects.DataObject1> id2 = InstanceIdentifier.create(DataObjects.DataObject1.class); final DataObjectUpdate update2 = mock(DataObjectUpdate.class); final WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates( Multimaps.forMap(Collections.singletonMap(id2, update2)), Multimaps.forMap(Collections.emptyMap())); build.processModifications(updates, mock(WriteContext.class)); }	@Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }
@Test public void testRelationsAfter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class)); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject3.class), DataObjects.DataObject2.IID); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject4.class), Lists.newArrayList(DataObjects.DataObject2.IID, DataObjects.DataObject3.IID)); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final List<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject1.IID, typesInList.get(0)); assertEquals(DataObjects.DataObject2.IID, typesInList.get(1)); assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); }	@VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }
@Test public void testAddSubtreeWriter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.subtreeAdd( Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID, DataObjects.DataObject4.DataObject41.IID), mockWriter(DataObjects.DataObject4.class)); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject4.IID, typesInList.get(0)); assertEquals(1, typesInList.size()); }	@VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }	FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }
@Test(expected = IllegalArgumentException.class) public void testSubtreeWriterCreationFail() throws Exception { SubtreeWriter.createForWriter(Collections.singleton(InstanceIdentifier.create(DataObject.class)), writer); }	static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }
@Test(expected = IllegalArgumentException.class) public void testSubtreeWriterCreationFailInvalidIid() throws Exception { SubtreeWriter.createForWriter(Collections.singleton(DataObjects.DataObject4.IID), writer); }	static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }	SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }
@Test public void testInvokeRpcNoResult() throws Exception { final DataObject outputBa = null; final ContainerNode outputBi = null; when(registry.invoke(path, input)).thenReturn(CompletableFuture.completedFuture(outputBa)); assertEquals(outputBi, service.invokeRpc(path, node).get().getResult()); }	@Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); @Nonnull @Override FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode); @Nonnull @Override ListenerRegistration<T> registerRpcListener(@Nonnull final T t); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); @Nonnull @Override FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode); @Nonnull @Override ListenerRegistration<T> registerRpcListener(@Nonnull final T t); }
@Test public void testCanHandleChild() throws Exception { final SubtreeWriter<?> forWriter = createSubtreeWriter(); InstanceIdentifier<DataObjects.DataObject4.DataObject41.DataObject411> testIid = InstanceIdentifier.create( DataObjects.DataObject4.class).child(DataObjects.DataObject4.DataObject41.class).child( DataObjects.DataObject4.DataObject41.DataObject411.class); assertTrue(forWriter.canProcess(testIid)); }	@Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); }	SubtreeWriter implements Writer<D> { @Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); } }	SubtreeWriter implements Writer<D> { @Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); }	SubtreeWriter implements Writer<D> { @Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }	SubtreeWriter implements Writer<D> { @Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override void processModification( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }
@Test public void testSubtreeWriterUpdateAggregation() throws Exception { Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); when(ctx.readAfter(DataObject1.IID)).thenReturn(Optional.of(mock(DataObject1.class))); when(ctx.readBefore(DataObject1.IID)).thenReturn(Optional.of(mock(DataObject1.class))); Writer<?> writer = SubtreeWriter.createForWriter(Collections.singleton(DataObjects.DataObject1ChildK.IID), writer1); InstanceIdentifier<DataObjects.DataObject1ChildK> update1Id = DataObject1.IID.child(DataObjects.DataObject1ChildK.class, new DataObjects.DataObject1ChildKey()); InstanceIdentifier<DataObjects.DataObject1ChildK> update2Id = DataObject1.IID.child(DataObjects.DataObject1ChildK.class, new DataObjects.DataObject1ChildKey()); updates.putAll(DataObjects.DataObject1ChildK.IID, Lists.newArrayList( DataObjectUpdate.create(update1Id, mock(DataObjects.DataObject1ChildK.class), mock(DataObjects.DataObject1ChildK.class)), DataObjectUpdate.create(update2Id, mock(DataObjects.DataObject1ChildK.class), mock(DataObjects.DataObject1ChildK.class)))); Collection<DataObjectUpdate> parentDataObjectUpdate = FlatWriterRegistry.getParentDataObjectUpdate(ctx, updates, writer); assertEquals(1, parentDataObjectUpdate.size()); }	static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testSubtreeWriterUpdateAggregationForList() throws Exception { Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); KeyedInstanceIdentifier<DataObjects.DataObject1ChildK, DataObjects.DataObject1ChildKey> parentKeyedId1 = DataObject1.IID.child(DataObjects.DataObject1ChildK.class, new DataObjects.DataObject1ChildKey()); KeyedInstanceIdentifier<DataObjects.DataObject1ChildK, DataObjects.DataObject1ChildKey> parentKeyedId2 = DataObject1.IID.child(DataObjects.DataObject1ChildK.class, new DataObjects.DataObject1ChildKey()); when(ctx.readBefore(parentKeyedId1)).thenReturn(Optional.of(mock(DataObjects.DataObject1ChildK.class))); when(ctx.readAfter(parentKeyedId1)).thenReturn(Optional.of(mock(DataObjects.DataObject1ChildK.class))); when(ctx.readBefore(parentKeyedId2)).thenReturn(Optional.of(mock(DataObjects.DataObject1ChildK.class))); when(ctx.readAfter(parentKeyedId2)).thenReturn(Optional.of(mock(DataObjects.DataObject1ChildK.class))); Writer<?> writer = SubtreeWriter.createForWriter(Sets.newHashSet( InstanceIdentifier.create(DataObjects.DataObject1ChildK.class).child(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class), InstanceIdentifier.create(DataObjects.DataObject1ChildK.class).child(DataObjects.DataObject1ChildK.DataObject1ChildKNested2.class)), writer4); InstanceIdentifier<DataObjects.DataObject1ChildK.DataObject1ChildKNested> updateList1Id = parentKeyedId1.child(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class); InstanceIdentifier<DataObjects.DataObject1ChildK.DataObject1ChildKNested> updateList2Id = parentKeyedId2.child(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class); updates.putAll(DataObjects.DataObject1ChildK.DataObject1ChildKNested.IID, Lists.newArrayList( DataObjectUpdate.create(updateList1Id, mock(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class), mock(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class)), DataObjectUpdate.create(updateList2Id, mock(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class), mock(DataObjects.DataObject1ChildK.DataObject1ChildKNested.class)))); Collection<DataObjectUpdate> parentDataObjectUpdate = FlatWriterRegistry.getParentDataObjectUpdate(ctx, updates, writer); assertEquals(2, parentDataObjectUpdate.size()); }	static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { static Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx, final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates, final Writer<?> writer) { return ((SubtreeWriter<?>) writer).getHandledChildTypes().stream() .filter(updates::containsKey) .map(unkeyedId -> updates.get(unkeyedId)) .flatMap(doUpdates -> doUpdates.stream()) .map(DataObjectUpdate::getId) .map(id -> getSingleParentDataObjectUpdate(ctx, (Multimap<InstanceIdentifier<?>, DataObjectUpdate>) updates, writer, id)) .collect(toMap(update -> RWUtils.cutId(update.getId(), writer.getManagedDataObjectType()), Function.identity(), (u1, u2) -> u1)) .values(); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleUpdatesForSingleWriter() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final InstanceIdentifier<DataObject1> iid2 = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject)); updates.put(DataObject1.IID, DataObjectUpdate.create(iid2, dataObject, dataObject)); flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); verify(writer1).processModification(iid, dataObject, dataObject, ctx); verify(writer1).processModification(iid2, dataObject, dataObject, ctx); verifyNoMoreInteractions(writer1); verifyZeroInteractions(writer2); }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleUpdatesForMultipleWriters() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject)); final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class); final DataObject2 dataObject2 = mock(DataObject2.class); updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2)); flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); final InOrder inOrder = inOrder(writer1, writer2); inOrder.verify(writer1).processModification(iid, dataObject, dataObject, ctx); inOrder.verify(writer2).processModification(iid2, dataObject2, dataObject2, ctx); verify(writer1,times(1)).processModification(any(),any(),any(),any()); verify(writer2,times(1)).processModification(any(),any(),any(),any()); }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleDeletesForMultipleWriters() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); deletes.put(DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null))); final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class); final DataObject2 dataObject2 = mock(DataObject2.class); deletes.put( DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null))); flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(ImmutableMultimap.of(), deletes), ctx); final InOrder inOrder = inOrder(writer1, writer2); inOrder.verify(writer2).processModification(iid2, dataObject2, null, ctx); inOrder.verify(writer1).processModification(iid, dataObject, null, ctx); verify(writer1,times(1)).processModification(any(),any(),any(),any()); verify(writer2,times(1)).processModification(any(),any(),any(),any()); }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleUpdatesAndDeletesForMultipleWriters() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); deletes.put(DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null))); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject)); final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class); final DataObject2 dataObject2 = mock(DataObject2.class); deletes.put( DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null))); updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2)); flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx); final InOrder inOrder = inOrder(writer1, writer2); inOrder.verify(writer2).processModification(iid2, dataObject2, null, ctx); inOrder.verify(writer1).processModification(iid, dataObject, null, ctx); inOrder.verify(writer1).processModification(iid, dataObject, dataObject, ctx); inOrder.verify(writer2).processModification(iid2, dataObject2, dataObject2, ctx); verify(writer1,times(2)).processModification(any(),any(),any(),any()); verify(writer2,times(2)).processModification(any(),any(),any(),any()); }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test(expected = IllegalArgumentException.class) public void testMultipleUpdatesOneMissing() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleUpdatesFirstFailing() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); doThrow(new RuntimeException()).when(writer1) .processModification(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); try { flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); fail("Bulk update should have failed on writer1 with UpdateFailedException"); } catch (UpdateFailedException e) { assertThat(e.getProcessed(), hasSize(0)); } }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMultipleUpdatesSecondFailing() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); doThrow(new RuntimeException()).when(writer2) .processModification(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); try { flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); fail("Bulk update should have failed on writer1 with UpdateFailedException"); } catch (UpdateFailedException e) { final List<DataObjectUpdate> alreadyProcessed = e.getProcessed(); assertThat(alreadyProcessed, hasSize(1)); assertEquals(updateData(DataObject1.class, DataObject1.IID), e.getProcessed().iterator().next()); } }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test(expected = ExecutionException.class) public void testInvokeRpcFailed() throws Exception { final CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException()); when(registry.invoke(path, input)).thenReturn(future); service.invokeRpc(path, node).get(); }	@Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); @Nonnull @Override FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode); @Nonnull @Override ListenerRegistration<T> registerRpcListener(@Nonnull final T t); }	HoneycombDOMRpcService implements DOMRpcService { @Nonnull @Override public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode) { DataObject input = null; if (normalizedNode != null) { final SchemaPath nodePatch = schemaPath.createChild(normalizedNode.getNodeType()); input = serializer.fromNormalizedNodeRpcData(nodePatch, (ContainerNode) normalizedNode); } final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture(); final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result)); return FluentFuture.from(output); } HoneycombDOMRpcService(@Nonnull final BindingNormalizedNodeSerializer serializer, @Nonnull final RpcRegistry rpcRegistry); @Nonnull @Override FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath, @Nullable final NormalizedNode<?, ?> normalizedNode); @Nonnull @Override ListenerRegistration<T> registerRpcListener(@Nonnull final T t); }
@Test public void testMultipleUpdatesLastFailing() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry( ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3)); doThrow(new RuntimeException()).when(writer3) .processModification(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); addUpdate(updates, DataObjects.DataObject3.class); try { flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); fail("Bulk update should have failed on writer1 with UpdateFailedException"); } catch (UpdateFailedException e) { final List<DataObjectUpdate> alreadyProcessed = e.getProcessed(); assertEquals(2, alreadyProcessed.size()); assertTrue(alreadyProcessed.contains(updateData(DataObject1.class, DataObject1.IID))); assertTrue(alreadyProcessed.contains(updateData(DataObject2.class, DataObject2.IID))); } }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testMutlipleUpdatesWithOneKeyedContainer() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry( ImmutableMap.of(DataObject1.IID, writer1, DataObjects.DataObject1ChildK.IID, writer4)); doThrow(new RuntimeException()).when(writer1) .processModification(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addKeyedUpdate(updates, DataObjects.DataObject1ChildK.class); addUpdate(updates, DataObject1.class); try { flatWriterRegistry.processModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); fail("Bulk update should have failed on writer1 with UpdateFailedException"); } catch (UpdateFailedException e) { assertTrue(e.getProcessed().isEmpty()); } }	@Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws TranslationException { if (updates.isEmpty()) { return; } final List<DataObjectUpdate> alreadyProcessed = new LinkedList<>(); if (updates.containsOnlySingleType()) { singleUpdate(updates.getDeletes(), alreadyProcessed, ctx); singleUpdate(updates.getUpdates(), alreadyProcessed, ctx); } else { bulkUpdate(updates.getDeletes(), alreadyProcessed, ctx, writersOrderReversed); bulkUpdate(updates.getUpdates(), alreadyProcessed, ctx, writersOrder); } LOG.debug("Update successful for types: {}", updates.getTypeIntersection()); LOG.trace("Update successful for: {}", updates); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test(expected = IllegalArgumentException.class) public void testValidateMissingWriter() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); flatWriterRegistry.validateModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); }	@Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testValidateSingleWriter() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final InstanceIdentifier<DataObject1> iid2 = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject)); updates.put(DataObject1.IID, DataObjectUpdate.create(iid2, dataObject, dataObject)); flatWriterRegistry .validateModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); verify(writer1).validate(iid, dataObject, dataObject, ctx); verify(writer1).validate(iid2, dataObject, dataObject, ctx); verifyNoMoreInteractions(writer1); verifyZeroInteractions(writer2); }	@Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test public void testValidateMultipleWriters() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); deletes.put(DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null))); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, null, dataObject)); final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class); final DataObject2 dataObject2 = mock(DataObject2.class); deletes.put(DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null))); updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2)); flatWriterRegistry.validateModifications(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx); verify(writer1).validate(iid, dataObject, null, ctx); verify(writer1).validate(iid, null, dataObject, ctx); verify(writer2).validate(iid2, dataObject2, null, ctx); verify(writer2).validate(iid2, dataObject2, dataObject2, ctx); verifyNoMoreInteractions(writer1); verifyNoMoreInteractions(writer2); }	@Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }	FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }
@Test(expected = WriteFailedException.CreateFailedException.class) public void testWriteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); }	@Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdateFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); }	@Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); }	@Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }	GenericListWriter extends AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final ListWriterCustomizer<D, K> customizer, @Nonnull final Validator<D> validator); }
@Test(expected = WriteFailedException.CreateFailedException.class) public void testWriteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); }	@Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdateFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); }	@Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }
@Test public void testCreateFailed() throws Exception { final WriteFailedException.CreateFailedException cause = new WriteFailedException.CreateFailedException(id, dataAfter); final WriteFailedException.CreateFailedException createFailedException = new WriteFailedException.CreateFailedException(id, dataAfter, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getData(), dataAfter); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to create")); }	@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 = WriteFailedException.DeleteFailedException.class) public void testDeleteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); }	@Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }
@Test public void testUpdateSupported() { assertFalse(GenericWriter.isUpdateSupported(new NoopWriters.NonDirectUpdateWriterCustomizer())); assertTrue(GenericWriter.isUpdateSupported(new NoopWriters.DirectUpdateWriterCustomizer())); assertTrue(GenericWriter.isUpdateSupported(new NoopWriters.ParentImplDirectUpdateWriterCustomizer())); }	static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}\|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } }	GenericWriter extends AbstractGenericWriter<D> { static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}\|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } } }	GenericWriter extends AbstractGenericWriter<D> { static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}\|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}\|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }	GenericWriter extends AbstractGenericWriter<D> { static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}\|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type, @Nonnull final WriterCustomizer<D> customizer, @Nonnull final Validator<D> validator); }
@SuppressWarnings("unchecked") @Test public void testInit() throws Exception { final Initialized<TestingData> initialized = Initialized.create(DATA_OBJECT_ID, data); when(getCustomizer().isPresent(any(), any(), any())).thenReturn(true); doReturn(initialized).when(getCustomizer()).init(any(), any(), any()); when(writeTx.commit()).thenReturn(FluentFuture.from(Futures.immediateFuture(null))); when(broker.newWriteOnlyTransaction()).thenReturn(writeTx); getReader().init(broker, DATA_OBJECT_ID, ctx); verify(writeTx, times(2)).merge(CONFIGURATION, DATA_OBJECT_ID, data); verify(writeTx, times(2)).commit(); }	@Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }
@Test(expected = InitFailedException.class) public void testInitFailed() throws Exception { doThrow(new ReadFailedException(DATA_OBJECT_ID)).when(getCustomizer()) .readCurrentAttributes(any(), any(), any()); getReader().init(broker, DATA_OBJECT_ID, ctx); verifyZeroInteractions(writeTx); }	@Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }	GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id, @Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }
@Test public void testReadFallback() throws Exception { compositeReader.read(DataObjects.DataObject4.DataObject42.IID, ctx); verify(reader4).read(DataObjects.DataObject4.DataObject42.IID, ctx); verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); }	@Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } }	CompositeReader extends AbstractGenericReader<D, B> implements InitReader<D, B>, DelegatingReader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } } }	CompositeReader extends AbstractGenericReader<D, B> implements InitReader<D, B>, DelegatingReader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } } private CompositeReader(final Reader<D, B> reader, final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders); }	CompositeReader extends AbstractGenericReader<D, B> implements InitReader<D, B>, DelegatingReader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } } private CompositeReader(final Reader<D, B> reader, final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders); @SuppressWarnings("unchecked") static InstanceIdentifier<D> appendTypeToId( final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx); @SuppressWarnings("unchecked") @Override void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx); }	CompositeReader extends AbstractGenericReader<D, B> implements InitReader<D, B>, DelegatingReader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } } private CompositeReader(final Reader<D, B> reader, final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders); @SuppressWarnings("unchecked") static InstanceIdentifier<D> appendTypeToId( final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx); @SuppressWarnings("unchecked") @Override void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx); }
@Test public void testReadAll() throws Exception { reg.readAll(ctx); final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41); inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(rootReader4).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader41).read(any(InstanceIdentifier.class), any(ReadContext.class)); }	@Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; }	CompositeReaderRegistry implements ReaderRegistry { @Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; } }	CompositeReaderRegistry implements ReaderRegistry { @Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); }	CompositeReaderRegistry implements ReaderRegistry { @Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override String toString(); }	CompositeReaderRegistry implements ReaderRegistry { @Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override String toString(); }
@Test public void testReadSingleRoot() throws Exception { reg.read(DataObject3.IID, ctx); final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41); inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class)); verify(rootReader4, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); }	@Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); }	CompositeReaderRegistry implements ReaderRegistry { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); } }	CompositeReaderRegistry implements ReaderRegistry { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); }	CompositeReaderRegistry implements ReaderRegistry { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override String toString(); }	CompositeReaderRegistry implements ReaderRegistry { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void testCreateInvalid() throws Exception { SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject1.IID), delegate); }	static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); }	SubtreeReader implements DelegatingReader<D, B> { static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); } }	SubtreeReader implements DelegatingReader<D, B> { static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); } SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes); }	SubtreeReader implements DelegatingReader<D, B> { static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); } SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes); @Override @Nonnull Optional<? extends DataObject> read( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }	SubtreeReader implements DelegatingReader<D, B> { static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); } SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes); @Override @Nonnull Optional<? extends DataObject> read( @Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }
@Test public void testInit() throws Exception { final InitReader<DataObject1, Builder<DataObject1>> initSubReader = InitSubtreeReader.createForReader(Sets.newHashSet(DataObject1.DataObject11.IID), delegate); assertFalse(initSubReader instanceof ListReader); initSubReader.init(broker, DataObject1.IID, ctx); verify(delegate).init(broker, DataObject1.IID, ctx); }	@Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); }	InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } }	InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } private InitSubtreeReader(final InitReader<O, B> delegate, final Set<InstanceIdentifier<?>> handledTypes); }	InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } private InitSubtreeReader(final InitReader<O, B> delegate, final Set<InstanceIdentifier<?>> handledTypes); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }	InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } private InitSubtreeReader(final InitReader<O, B> delegate, final Set<InstanceIdentifier<?>> handledTypes); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }
@Test(expected = IllegalArgumentException.class) public void testPreventStructuralReaderForList() { new CompositeReaderRegistryBuilder(new YangDAG()).addStructuralReader(InstanceIdentifier.create(DataObjects.DataObjectK.class), DataObjects.DataObjectKBuilder.class); }	@Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); }	CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } }	CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); }	CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType); @Override void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys); @Override ReaderRegistry build(); }	CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType); @Override void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys); @Override ReaderRegistry build(); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.