*/
package org.opendaylight.controller.md.sal.dom.broker.impl;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
-
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-
public class DOMTransactionChainTest {
private SchemaContext schemaContext;
- private DOMDataBrokerImpl domBroker;
+ private AbstractDOMDataBroker domBroker;
@Before
public void setupStore() {
- InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", MoreExecutors.sameThreadExecutor());
- InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", MoreExecutors.sameThreadExecutor());
+ InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", MoreExecutors.newDirectExecutorService());
+ InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", MoreExecutors.newDirectExecutorService());
schemaContext = TestModel.createTestContext();
operStore.onGlobalContextUpdated(schemaContext);
.build();
ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
- domBroker = new DOMDataBrokerImpl(stores, executor);
+ domBroker = new SerializedDOMDataBroker(stores, executor);
}
@Test
/**
* We alocate new read-write transaction and write /test
- *
- *
+ *
+ *
*/
DOMDataReadWriteTransaction firstTx = allocateAndWrite(txChain);
* First transaction is marked as ready, we are able to allocate chained
* transactions
*/
- ListenableFuture<RpcResult<TransactionStatus>> firstWriteTxFuture = firstTx.commit();
+ ListenableFuture<Void> firstWriteTxFuture = firstTx.submit();
/**
* We alocate chained transaction - read transaction.
DOMDataReadTransaction secondReadTx = txChain.newReadOnlyTransaction();
/**
- *
+ *
* We test if we are able to read data from tx, read should not fail
* since we are using chained transaction.
- *
- *
+ *
+ *
*/
assertTestContainerExists(secondReadTx);
/**
- *
+ *
* We alocate next transaction, which is still based on first one, but
* is read-write.
- *
+ *
*/
DOMDataReadWriteTransaction thirdDeleteTx = allocateAndDelete(txChain);
- /**
- * third transaction is sealed.
- */
- ListenableFuture<RpcResult<TransactionStatus>> thirdDeleteTxFuture = thirdDeleteTx.commit();
-
/**
* We commit first transaction
- *
+ *
*/
assertCommitSuccessful(firstWriteTxFuture);
- // Alocates store transaction
+ /**
+ *
+ * Allocates transaction from data store.
+ *
+ */
DOMDataReadTransaction storeReadTx = domBroker.newReadOnlyTransaction();
+
/**
* We verify transaction is commited to store, container should exists
* in datastore.
*/
assertTestContainerExists(storeReadTx);
+
/**
- * We commit third transaction
- *
+ * third transaction is sealed and commited
*/
+ ListenableFuture<Void> thirdDeleteTxFuture = thirdDeleteTx.submit();
assertCommitSuccessful(thirdDeleteTxFuture);
/**
/**
* We alocate new read-write transaction and write /test
- *
- *
+ *
+ *
*/
allocateAndWrite(txChain);
* IllegalStateException.
*/
try {
- DOMDataReadTransaction secondReadTx = txChain.newReadOnlyTransaction();
+ txChain.newReadOnlyTransaction();
fail("Allocation of secondReadTx should fail with IllegalStateException");
} catch (Exception e) {
assertTrue(e instanceof IllegalStateException);
}
}
- private static DOMDataReadWriteTransaction allocateAndDelete(DOMTransactionChain txChain)
+ private static DOMDataReadWriteTransaction allocateAndDelete(final DOMTransactionChain txChain)
throws InterruptedException, ExecutionException {
DOMDataReadWriteTransaction tx = txChain.newReadWriteTransaction();
/**
* We test existence of /test in third transaction container should
* still be visible from first one (which is still uncommmited).
- *
+ *
*/
assertTestContainerExists(tx);
return tx;
}
- private static DOMDataReadWriteTransaction allocateAndWrite(DOMTransactionChain txChain)
+ private static DOMDataReadWriteTransaction allocateAndWrite(final DOMTransactionChain txChain)
throws InterruptedException, ExecutionException {
DOMDataReadWriteTransaction tx = txChain.newReadWriteTransaction();
assertTestContainerWrite(tx);
return tx;
}
- private static void assertCommitSuccessful(ListenableFuture<RpcResult<TransactionStatus>> future)
+ private static void assertCommitSuccessful(final ListenableFuture<Void> future)
throws InterruptedException, ExecutionException {
- RpcResult<TransactionStatus> rpcResult = future.get();
- assertTrue(rpcResult.isSuccessful());
- assertEquals(TransactionStatus.COMMITED, rpcResult.getResult());
+ future.get();
}
- private static void assertTestContainerExists(DOMDataReadTransaction readTx) throws InterruptedException,
+ private static void assertTestContainerExists(final DOMDataReadTransaction readTx) throws InterruptedException,
ExecutionException {
ListenableFuture<Optional<NormalizedNode<?, ?>>> readFuture = readTx.read(OPERATIONAL, TestModel.TEST_PATH);
Optional<NormalizedNode<?, ?>> readedData = readFuture.get();
assertTrue(readedData.isPresent());
}
- private static void assertTestContainerWrite(DOMDataReadWriteTransaction tx) throws InterruptedException,
+ private static void assertTestContainerWrite(final DOMDataReadWriteTransaction tx) throws InterruptedException,
ExecutionException {
tx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
assertTestContainerExists(tx);
Code Review / controller.git / blobdiff