Change-Id: I6b24a1d061c94d57730b20cde4c5b3c39444b119
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>
LOG.info("Changes successfully reverted");
} catch (WriterRegistry.Reverter.RevertFailedException revertFailedException) {
// fail with failed revert
LOG.info("Changes successfully reverted");
} catch (WriterRegistry.Reverter.RevertFailedException revertFailedException) {
// fail with failed revert
- LOG.error("Failed to revert successful changes", revertFailedException);
+ LOG.error("Failed to revert successful(comitted) changes, failure occurred for: {}. State might be corrupted.",
+ revertFailedException.getFailedUpdate(), revertFailedException);
throw revertFailedException;
}
// fail with success revert
// not passing the cause,its logged above and it would be logged after transaction
// ended again(prevent double logging of same error
throw revertFailedException;
}
// fail with success revert
// not passing the cause,its logged above and it would be logged after transaction
// ended again(prevent double logging of same error
- throw new WriterRegistry.Reverter.RevertSuccessException(e.getFailedIds());
+ throw new WriterRegistry.Reverter.RevertSuccessException(e.getUnrevertedSubtrees());
} catch (TransactionCommitFailedException e) {
// TODO HONEYCOMB-162 revert should probably occur when context is not written successfully
final String msg = "Error while updating mapping context data";
} catch (TransactionCommitFailedException e) {
// TODO HONEYCOMB-162 revert should probably occur when context is not written successfully
final String msg = "Error while updating mapping context data";
final com.google.common.base.Optional<NormalizedNode<?, ?>> afterData =
modification.getDataAfter();
checkArgument(beforeData.isPresent() || afterData.isPresent(),
final com.google.common.base.Optional<NormalizedNode<?, ?>> afterData =
modification.getDataAfter();
checkArgument(beforeData.isPresent() || afterData.isPresent(),
- "Both before and after data are null for $s", modification.getId());
+ "Both before and after data are null for %s", modification.getId());
return NormalizedNodeUpdate.create(modification.getId(), beforeData.orNull(), afterData.orNull());
}
return NormalizedNodeUpdate.create(modification.getId(), beforeData.orNull(), afterData.orNull());
}
private ArgumentCaptor<WriteContext> writeContextCaptor;
private ModifiableDataTreeManager configDataTree;
private ArgumentCaptor<WriteContext> writeContextCaptor;
private ModifiableDataTreeManager configDataTree;
+ private final DataObjectUpdate update = DataObjectUpdate.create(DEFAULT_ID, null, DEFAULT_DATA_OBJECT);
static final InstanceIdentifier<?> DEFAULT_ID = InstanceIdentifier.create(DataObject.class);
static DataObject DEFAULT_DATA_OBJECT = mockDataObject("serialized", DataObject.class);
static final InstanceIdentifier<?> DEFAULT_ID = InstanceIdentifier.create(DataObject.class);
static DataObject DEFAULT_DATA_OBJECT = mockDataObject("serialized", DataObject.class);
// Fail on update:
final WriterRegistry.Reverter reverter = mock(WriterRegistry.Reverter.class);
final TranslationException failedOnUpdateException = new TranslationException("update failed");
// Fail on update:
final WriterRegistry.Reverter reverter = mock(WriterRegistry.Reverter.class);
final TranslationException failedOnUpdateException = new TranslationException("update failed");
- doThrow(new WriterRegistry.BulkUpdateException(Collections.singleton(DEFAULT_ID), reverter, failedOnUpdateException))
+ doThrow(new WriterRegistry.BulkUpdateException(DEFAULT_ID, update, Collections.singleton(DEFAULT_ID), reverter, failedOnUpdateException))
.when(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
try {
.when(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
try {
// Fail on update:
final WriterRegistry.Reverter reverter = mock(WriterRegistry.Reverter.class);
final TranslationException failedOnUpdateException = new TranslationException("update failed");
// Fail on update:
final WriterRegistry.Reverter reverter = mock(WriterRegistry.Reverter.class);
final TranslationException failedOnUpdateException = new TranslationException("update failed");
- doThrow(new WriterRegistry.BulkUpdateException(Collections.singleton(DEFAULT_ID), reverter, failedOnUpdateException))
- .when(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
+ final WriterRegistry.BulkUpdateException bulkFailEx =
+ new WriterRegistry.BulkUpdateException(DEFAULT_ID, update, Collections.singleton(DEFAULT_ID), reverter,
+ failedOnUpdateException);
+ doThrow(bulkFailEx).when(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
- final TranslationException failedOnRevertException = new TranslationException("revert failed");
- doThrow(new WriterRegistry.Reverter.RevertFailedException(Collections.emptySet(), failedOnRevertException))
+ doThrow(new WriterRegistry.Reverter.RevertFailedException(bulkFailEx))
.when(reverter).revert(any(WriteContext.class));
try {
.when(reverter).revert(any(WriteContext.class));
try {
} catch (WriterRegistry.Reverter.RevertFailedException e) {
verify(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
verify(reverter).revert(any(WriteContext.class));
} catch (WriterRegistry.Reverter.RevertFailedException e) {
verify(writer).update(any(WriterRegistry.DataObjectUpdates.class), any(WriteContext.class));
verify(reverter).revert(any(WriteContext.class));
- assertEquals(failedOnRevertException, e.getCause());
+ assertEquals(bulkFailEx, e.getCause());
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.Beta;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.Beta;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import io.fd.honeycomb.translate.TranslationException;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import io.fd.honeycomb.translate.TranslationException;
class BulkUpdateException extends TranslationException {
private final transient Reverter reverter;
class BulkUpdateException extends TranslationException {
private final transient Reverter reverter;
- private final Set<InstanceIdentifier<?>> failedIds;
+ private final InstanceIdentifier<?> failedSubtree;
+ private final DataObjectUpdate failedData;
+ private final Set<InstanceIdentifier<?>> unrevertedSubtrees;
/**
* Constructs an BulkUpdateException.
/**
* Constructs an BulkUpdateException.
- * @param failedIds instance identifiers of the data objects that were not processed during bulk update.
+ * @param unhandledSubtrees instance identifiers of the data objects that were not processed during bulk update.
* @param cause the cause of bulk update failure
*/
* @param cause the cause of bulk update failure
*/
- public BulkUpdateException(@Nonnull final Set<InstanceIdentifier<?>> failedIds,
+ public BulkUpdateException(@Nonnull final InstanceIdentifier<?> failedSubtree,
+ @Nonnull final DataObjectUpdate failedData,
+ @Nonnull final Set<InstanceIdentifier<?>> unhandledSubtrees,
@Nonnull final Reverter reverter,
@Nonnull final Throwable cause) {
@Nonnull final Reverter reverter,
@Nonnull final Throwable cause) {
- super("Bulk update failed at: " + failedIds, cause);
- this.failedIds = failedIds;
+ super("Bulk update failed at: " + failedSubtree + " ignored updates: " + unhandledSubtrees, cause);
+ this.failedSubtree = failedSubtree;
+ this.failedData = failedData;
+ this.unrevertedSubtrees = unhandledSubtrees;
this.reverter = checkNotNull(reverter, "reverter should not be null");
}
this.reverter = checkNotNull(reverter, "reverter should not be null");
}
reverter.revert(writeContext);
}
reverter.revert(writeContext);
}
- public Set<InstanceIdentifier<?>> getFailedIds() {
- return failedIds;
+ public Set<InstanceIdentifier<?>> getUnrevertedSubtrees() {
+ return unrevertedSubtrees;
+ }
+
+ public InstanceIdentifier<?> getFailedSubtree() {
+ return failedSubtree;
+ }
+
+ public DataObjectUpdate getFailedData() {
+ return failedData;
@Beta
class RevertFailedException extends TranslationException {
@Beta
class RevertFailedException extends TranslationException {
- // TODO HONEYCOMB-170 change to list of VppDataModifications to make debugging easier
- private final Set<InstanceIdentifier<?>> notRevertedChanges;
-
/**
* Constructs a RevertFailedException with the list of changes that were not reverted.
*
/**
* Constructs a RevertFailedException with the list of changes that were not reverted.
*
- * @param notRevertedChanges list of changes that were not reverted
* @param cause the cause of revert failure
*/
* @param cause the cause of revert failure
*/
- public RevertFailedException(@Nonnull final Set<InstanceIdentifier<?>> notRevertedChanges,
- final Throwable cause) {
- super(cause);
- checkNotNull(notRevertedChanges, "notRevertedChanges should not be null");
- this.notRevertedChanges = ImmutableSet.copyOf(notRevertedChanges);
+ public RevertFailedException(@Nonnull final BulkUpdateException cause) {
+ super("Unable to revert changes after failure. Revert failed for "
+ + cause.getFailedSubtree() + " unreverted subtrees: " + cause.getUnrevertedSubtrees(), cause);
*/
@Nonnull
public Set<InstanceIdentifier<?>> getNotRevertedChanges() {
*/
@Nonnull
public Set<InstanceIdentifier<?>> getNotRevertedChanges() {
- return notRevertedChanges;
+ return ((BulkUpdateException) getCause()).getUnrevertedSubtrees();
+ }
+
+ /**
+ * Returns the update that caused the failure.
+ *
+ * @return update that caused the failure
+ */
+ @Nonnull
+ public DataObjectUpdate getFailedUpdate() {
+ return ((BulkUpdateException) getCause()).getFailedData();
import static org.mockito.Mockito.verify;
import com.google.common.collect.Sets;
import static org.mockito.Mockito.verify;
import com.google.common.collect.Sets;
+import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import java.util.HashSet;
import org.junit.Before;
import io.fd.honeycomb.translate.write.WriteContext;
import java.util.HashSet;
import org.junit.Before;
@Mock
private WriteContext writeContext;
@Mock
private WriteContext writeContext;
@Mock
private WriterRegistry.Reverter reverter;
@Mock
private WriterRegistry.Reverter reverter;
+ @Mock
+ private DataObject before;
+ @Mock
+ private DataObject after;
@Before
public void setUp() throws Exception {
@Before
public void setUp() throws Exception {
public void testRevert() throws Exception {
final HashSet<InstanceIdentifier<?>> failedIds = Sets.newHashSet(id);
final WriterRegistry.BulkUpdateException bulkUpdateException =
public void testRevert() throws Exception {
final HashSet<InstanceIdentifier<?>> failedIds = Sets.newHashSet(id);
final WriterRegistry.BulkUpdateException bulkUpdateException =
- new WriterRegistry.BulkUpdateException(failedIds, reverter, new RuntimeException());
+ new WriterRegistry.BulkUpdateException(id, DataObjectUpdate.create(id, before, after),
+ failedIds, reverter, new RuntimeException());
- assertEquals(failedIds, bulkUpdateException.getFailedIds());
+ assertEquals(failedIds, bulkUpdateException.getUnrevertedSubtrees());
bulkUpdateException.revertChanges(writeContext);
verify(reverter).revert(writeContext);
bulkUpdateException.revertChanges(writeContext);
verify(reverter).revert(writeContext);
import static org.junit.Assert.assertEquals;
import com.google.common.collect.Sets;
import static org.junit.Assert.assertEquals;
import com.google.common.collect.Sets;
+import io.fd.honeycomb.translate.write.DataObjectUpdate;
+import org.junit.Before;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class RevertFailedExceptionTest {
private InstanceIdentifier<?> id = InstanceIdentifier.create(DataObject.class);
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class RevertFailedExceptionTest {
private InstanceIdentifier<?> id = InstanceIdentifier.create(DataObject.class);
+ @Mock
+ private WriterRegistry.Reverter reverter;
+ @Mock
+ private DataObject before;
+ @Mock
+ private DataObject after;
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ }
@Test
public void testNonRevert() throws Exception {
final Set<InstanceIdentifier<?>> notReverted = Sets.newHashSet(id);
final WriterRegistry.Reverter.RevertFailedException revertFailedException =
@Test
public void testNonRevert() throws Exception {
final Set<InstanceIdentifier<?>> notReverted = Sets.newHashSet(id);
final WriterRegistry.Reverter.RevertFailedException revertFailedException =
- new WriterRegistry.Reverter.RevertFailedException(notReverted, new RuntimeException());
+ new WriterRegistry.Reverter.RevertFailedException(
+ new WriterRegistry.BulkUpdateException(id, DataObjectUpdate.create(id, before, after),
+ notReverted, reverter, new RuntimeException()));
assertEquals(notReverted, revertFailedException.getNotRevertedChanges());
}
}
\ No newline at end of file
assertEquals(notReverted, revertFailedException.getNotRevertedChanges());
}
}
\ No newline at end of file
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-all</artifactId>
+ <scope>test</scope>
+ </dependency>
.map(DataObjectUpdate::getId)
.filter(id -> !processedNodes.contains(id))
.collect(Collectors.toSet());
.map(DataObjectUpdate::getId)
.filter(id -> !processedNodes.contains(id))
.collect(Collectors.toSet());
- throw new BulkUpdateException(unprocessedChanges, reverter, e);
+ throw new BulkUpdateException(writerType, singleUpdate, unprocessedChanges, reverter, e);
LOG.info("Revert successful");
} catch (BulkUpdateException e) {
LOG.error("Revert failed", e);
LOG.info("Revert successful");
} catch (BulkUpdateException e) {
LOG.error("Revert failed", e);
- throw new RevertFailedException(e.getFailedIds(), e);
+ throw new RevertFailedException(e);
package io.fd.honeycomb.translate.impl.write.registry;
package io.fd.honeycomb.translate.impl.write.registry;
+import static org.hamcrest.CoreMatchers.hasItem;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import com.google.common.collect.Multimap;
import io.fd.honeycomb.translate.util.DataObjects;
import io.fd.honeycomb.translate.util.DataObjects.DataObject1;
import com.google.common.collect.Multimap;
import io.fd.honeycomb.translate.util.DataObjects;
import io.fd.honeycomb.translate.util.DataObjects.DataObject1;
+import io.fd.honeycomb.translate.util.DataObjects.DataObject2;
import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.Writer;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.Writer;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import org.hamcrest.CoreMatchers;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
@Mock
private Writer<DataObject1> writer1;
@Mock
@Mock
private Writer<DataObject1> writer1;
@Mock
- private Writer<DataObjects.DataObject2> writer2;
+ private Writer<DataObject2> writer2;
@Mock
private Writer<DataObjects.DataObject3> writer3;
@Mock
@Mock
private Writer<DataObjects.DataObject3> writer3;
@Mock
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- when(writer1.getManagedDataObjectType()).thenReturn(DataObjects.DataObject1.IID);
- when(writer2.getManagedDataObjectType()).thenReturn(DataObjects.DataObject2.IID);
+ when(writer1.getManagedDataObjectType()).thenReturn(DataObject1.IID);
+ when(writer2.getManagedDataObjectType()).thenReturn(DataObject2.IID);
when(writer3.getManagedDataObjectType()).thenReturn(DataObjects.DataObject3.IID);
}
@Test
public void testMultipleUpdatesForSingleWriter() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
when(writer3.getManagedDataObjectType()).thenReturn(DataObjects.DataObject3.IID);
}
@Test
public void testMultipleUpdatesForSingleWriter() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
+ new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final InstanceIdentifier<DataObjects.DataObject1> iid2 = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid2, dataObject, dataObject));
+ 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.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
verify(writer1).update(iid, dataObject, dataObject, ctx);
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
verify(writer1).update(iid, dataObject, dataObject, ctx);
@Test
public void testMultipleUpdatesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
@Test
public void testMultipleUpdatesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
+ new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2));
+ 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.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
@Test
public void testMultipleDeletesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
@Test
public void testMultipleDeletesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
+ new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create();
final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- deletes.put(DataObjects.DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null)));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
- deletes.put(DataObjects.DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null)));
+ 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.update(new WriterRegistry.DataObjectUpdates(ImmutableMultimap.of(), deletes), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(ImmutableMultimap.of(), deletes), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
@Test
public void testMultipleUpdatesAndDeletesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
@Test
public void testMultipleUpdatesAndDeletesForMultipleWriters() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
+ 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 Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create();
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
+ final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class);
+ final DataObject1 dataObject = mock(DataObject1.class);
- deletes.put(DataObjects.DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null)));
+ deletes.put(DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null)));
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
+ 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(DataObjects.DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null)));
+ deletes.put(
+ DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null)));
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2));
+ updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2));
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx);
final InOrder inOrder = inOrder(writer1, writer2);
@Test(expected = IllegalArgumentException.class)
public void testMultipleUpdatesOneMissing() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
@Test(expected = IllegalArgumentException.class)
public void testMultipleUpdatesOneMissing() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1));
+ new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
+ addUpdate(updates, DataObject1.class);
+ addUpdate(updates, DataObject2.class);
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
}
@Test
public void testMultipleUpdatesOneFailing() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
}
@Test
public void testMultipleUpdatesOneFailing() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
+ new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2));
// Writer1 always fails
doThrow(new RuntimeException()).when(writer1)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
// Writer1 always fails
doThrow(new RuntimeException()).when(writer1)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
+ addUpdate(updates, DataObject1.class);
+ addUpdate(updates, DataObject2.class);
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
} catch (WriterRegistry.BulkUpdateException e) {
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
} catch (WriterRegistry.BulkUpdateException e) {
- assertThat(e.getFailedIds().size(), is(2));
- assertThat(e.getFailedIds(), CoreMatchers.hasItem(InstanceIdentifier.create(DataObjects.DataObject2.class)));
- assertThat(e.getFailedIds(), CoreMatchers.hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
+ assertThat(e.getUnrevertedSubtrees(), hasSize(2));
+ assertThat(e.getUnrevertedSubtrees(), hasItem(InstanceIdentifier.create(DataObject2.class)));
+ assertThat(e.getUnrevertedSubtrees(), hasItem(InstanceIdentifier.create(DataObject1.class)));
public void testMultipleUpdatesOneFailingThenRevertWithSuccess() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
public void testMultipleUpdatesOneFailingThenRevertWithSuccess() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
+ ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
// Writer1 always fails
doThrow(new RuntimeException()).when(writer3)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
// Writer1 always fails
doThrow(new RuntimeException()).when(writer3)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
+ addUpdate(updates, DataObject1.class);
addUpdate(updates, DataObjects.DataObject3.class);
addUpdate(updates, DataObjects.DataObject3.class);
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 before2 = mock(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 after2 = mock(DataObjects.DataObject2.class);
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, before2, after2));
+ final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class);
+ final DataObject2 before2 = mock(DataObject2.class);
+ final DataObject2 after2 = mock(DataObject2.class);
+ updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, before2, after2));
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
} catch (WriterRegistry.BulkUpdateException e) {
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
} catch (WriterRegistry.BulkUpdateException e) {
- assertThat(e.getFailedIds().size(), is(1));
+ assertThat(e.getUnrevertedSubtrees().size(), is(1));
final InOrder inOrder = inOrder(writer1, writer2, writer3);
inOrder.verify(writer1)
final InOrder inOrder = inOrder(writer1, writer2, writer3);
inOrder.verify(writer1)
public void testMultipleUpdatesOneFailingThenRevertWithFail() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
public void testMultipleUpdatesOneFailingThenRevertWithFail() throws Exception {
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
+ ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
// Writer1 always fails
doThrow(new RuntimeException()).when(writer3)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
// Writer1 always fails
doThrow(new RuntimeException()).when(writer3)
.update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
+ addUpdate(updates, DataObject1.class);
+ addUpdate(updates, DataObject2.class);
addUpdate(updates, DataObjects.DataObject3.class);
try {
addUpdate(updates, DataObjects.DataObject3.class);
try {
e.revertChanges(revertWriteContext);
} catch (WriterRegistry.Reverter.RevertFailedException e1) {
assertThat(e1.getNotRevertedChanges().size(), is(1));
e.revertChanges(revertWriteContext);
} catch (WriterRegistry.Reverter.RevertFailedException e1) {
assertThat(e1.getNotRevertedChanges().size(), is(1));
- assertThat(e1.getNotRevertedChanges(), CoreMatchers
- .hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
+ assertThat(e1.getNotRevertedChanges(),
+ hasItem(InstanceIdentifier.create(DataObject1.class)));
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
final FlatWriterRegistry flatWriterRegistry =
new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject1ChildK.IID,writer4));
+ ImmutableMap.of(DataObject1.IID, writer1, DataObjects.DataObject1ChildK.IID,writer4));
// Writer1 always fails
doThrow(new RuntimeException()).when(writer1)
// Writer1 always fails
doThrow(new RuntimeException()).when(writer1)
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
addKeyedUpdate(updates,DataObjects.DataObject1ChildK.class);
final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
addKeyedUpdate(updates,DataObjects.DataObject1ChildK.class);
- addUpdate(updates, DataObjects.DataObject1.class);
+ addUpdate(updates, DataObject1.class);
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
try {
flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
fail("Bulk update should have failed on writer1");
e.revertChanges(revertWriteContext);
} catch (WriterRegistry.Reverter.RevertFailedException e1) {
assertThat(e1.getNotRevertedChanges().size(), is(1));
e.revertChanges(revertWriteContext);
} catch (WriterRegistry.Reverter.RevertFailedException e1) {
assertThat(e1.getNotRevertedChanges().size(), is(1));
- assertThat(e1.getNotRevertedChanges(), CoreMatchers
- .hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
+ assertThat(e1.getNotRevertedChanges(),
+ hasItem(InstanceIdentifier.create(DataObject1.class)));