dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/DOMBrokerTest.java

   1 /*
   2  * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.dom.broker;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
  15 import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
  16
  17 import com.google.common.base.Optional;
  18 import com.google.common.collect.ImmutableMap;
  19 import com.google.common.util.concurrent.ForwardingExecutorService;
  20 import com.google.common.util.concurrent.ListenableFuture;
  21 import com.google.common.util.concurrent.ListeningExecutorService;
  22 import com.google.common.util.concurrent.MoreExecutors;
  23 import java.util.Collections;
  24 import java.util.concurrent.ExecutionException;
  25 import java.util.concurrent.ExecutorService;
  26 import java.util.concurrent.Executors;
  27 import java.util.concurrent.RejectedExecutionException;
  28 import java.util.concurrent.TimeUnit;
  29 import java.util.concurrent.atomic.AtomicReference;
  30 import org.junit.After;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.Mockito;
  34 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  35 import org.opendaylight.mdsal.common.api.ReadFailedException;
  36 import org.opendaylight.mdsal.common.api.TransactionCommitDeadlockException;
  37 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
  38 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  39 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  40 import org.opendaylight.mdsal.dom.broker.util.TestModel;
  41 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
  42 import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
  43 import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
  44 import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
  45 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  46 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  47 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  48 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  49 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  50 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  51
  52 public class DOMBrokerTest {
  53
  54     private SchemaContext schemaContext;
  55     private AbstractDOMDataBroker domBroker;
  56     private ListeningExecutorService executor;
  57     private ExecutorService futureExecutor;
  58     private CommitExecutorService commitExecutor;
  59
  60     @Before
  61     public void setupStore() {
  62         final InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER",
  63                 MoreExecutors.newDirectExecutorService());
  64         final InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG",
  65                 MoreExecutors.newDirectExecutorService());
  66         schemaContext = TestModel.createTestContext();
  67
  68         operStore.onGlobalContextUpdated(schemaContext);
  69         configStore.onGlobalContextUpdated(schemaContext);
  70
  71         final ImmutableMap<LogicalDatastoreType, DOMStore> stores =
  72                 ImmutableMap.<LogicalDatastoreType, DOMStore>builder()
  73                 .put(CONFIGURATION, configStore)
  74                 .put(OPERATIONAL, operStore)
  75                 .build();
  76
  77         commitExecutor = new CommitExecutorService(Executors.newSingleThreadExecutor());
  78         futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB", DOMBrokerTest.class);
  79         executor = new DeadlockDetectingListeningExecutorService(commitExecutor,
  80                 TransactionCommitDeadlockException.DEADLOCK_EXCEPTION_SUPPLIER, futureExecutor);
  81         domBroker = new SerializedDOMDataBroker(stores, executor);
  82     }
  83
  84     @After
  85     public void tearDown() {
  86         if (executor != null) {
  87             executor.shutdownNow();
  88         }
  89
  90         if (futureExecutor != null) {
  91             futureExecutor.shutdownNow();
  92         }
  93     }
  94
  95     @Test(timeout = 10000)
  96     public void testTransactionIsolation() throws InterruptedException, ExecutionException {
  97         assertNotNull(domBroker);
  98
  99         final DOMDataTreeReadTransaction readTx = domBroker.newReadOnlyTransaction();
 100         assertNotNull(readTx);
 101
 102         final DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
 103         assertNotNull(writeTx);
 104
 105         /**
 106          * Writes /test in writeTx.
 107          *
 108          */
 109         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 110
 111         /**
 112          * Reads /test from readTx Read should return Absent.
 113          *
 114          */
 115         final ListenableFuture<Optional<NormalizedNode<?, ?>>> readTxContainer = readTx
 116                 .read(OPERATIONAL, TestModel.TEST_PATH);
 117         assertFalse(readTxContainer.get().isPresent());
 118     }
 119
 120     @Test(timeout = 10000)
 121     public void testTransactionCommit() throws InterruptedException, ExecutionException {
 122         final DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
 123         assertNotNull(writeTx);
 124         /**
 125          * Writes /test in writeTx
 126          *
 127          */
 128         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 129
 130         writeTx.commit().get();
 131
 132         final Optional<NormalizedNode<?, ?>> afterCommitRead = domBroker.newReadOnlyTransaction()
 133                 .read(OPERATIONAL, TestModel.TEST_PATH).get();
 134         assertTrue(afterCommitRead.isPresent());
 135     }
 136
 137     @Test(expected = TransactionCommitFailedException.class)
 138     @SuppressWarnings({"checkstyle:AvoidHidingCauseException", "checkstyle:IllegalThrows"})
 139     public void testRejectedCommit() throws Throwable {
 140         commitExecutor.delegate = Mockito.mock(ExecutorService.class);
 141         Mockito.doThrow(new RejectedExecutionException("mock"))
 142             .when(commitExecutor.delegate).execute(Mockito.any(Runnable.class));
 143         Mockito.doNothing().when(commitExecutor.delegate).shutdown();
 144         Mockito.doReturn(Collections.emptyList()).when(commitExecutor.delegate).shutdownNow();
 145         Mockito.doReturn("").when(commitExecutor.delegate).toString();
 146         Mockito.doReturn(Boolean.TRUE).when(commitExecutor.delegate)
 147             .awaitTermination(Mockito.anyLong(), Mockito.any(TimeUnit.class));
 148
 149         final DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
 150         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 151
 152         try {
 153             writeTx.commit().get(5, TimeUnit.SECONDS);
 154         } catch (ExecutionException e) {
 155             throw e.getCause();
 156         }
 157     }
 158
 159     @SuppressWarnings("checkstyle:IllegalCatch")
 160     AtomicReference<Throwable> submitTxAsync(final DOMDataTreeWriteTransaction writeTx) {
 161         final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
 162         new Thread() {
 163             @Override
 164             public void run() {
 165
 166                 try {
 167                     writeTx.commit();
 168                 } catch (final Throwable e) {
 169                     caughtEx.set(e);
 170                 }
 171             }
 172
 173         }.start();
 174
 175         return caughtEx;
 176     }
 177
 178     @Test(expected = ReadFailedException.class)
 179     public void basicTests() throws Exception {
 180         final DataContainerChild<?, ?> outerList = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
 181                 .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1))
 182                 .build();
 183         final NormalizedNode<?, ?> testContainer = Builders.containerBuilder()
 184                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
 185                 .withChild(outerList)
 186                 .build();
 187
 188         DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
 189         final DOMDataTreeReadTransaction readRx = domBroker.newReadOnlyTransaction();
 190         assertNotNull(writeTx);
 191         assertNotNull(readRx);
 192         assertNotNull(((SerializedDOMDataBroker) domBroker).getCommitStatsTracker());
 193
 194         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 195         writeTx.commit().get();
 196         assertFalse(writeTx.cancel());
 197
 198         assertEquals(false, domBroker.newReadOnlyTransaction().exists(CONFIGURATION, TestModel.TEST_PATH).get());
 199         assertEquals(true, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST_PATH).get());
 200         assertEquals(false, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST2_PATH).get());
 201
 202         writeTx = domBroker.newWriteOnlyTransaction();
 203         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 204         writeTx.delete(OPERATIONAL, TestModel.TEST_PATH);
 205         writeTx.commit().get();
 206         assertEquals(false, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST_PATH).get());
 207         assertTrue(domBroker.newWriteOnlyTransaction().cancel());
 208
 209         writeTx = domBroker.newWriteOnlyTransaction();
 210         writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 211         writeTx.merge(OPERATIONAL, TestModel.TEST_PATH, testContainer);
 212         writeTx.commit().get();
 213         assertEquals(Boolean.TRUE, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST_PATH).get());
 214         assertEquals(Boolean.TRUE, domBroker.newReadOnlyTransaction().read(OPERATIONAL, TestModel.TEST_PATH).get()
 215                  .get().toString().contains(testContainer.toString()));
 216
 217         readRx.close();
 218         //Expected exception after close call
 219         readRx.read(OPERATIONAL, TestModel.TEST_PATH).checkedGet();
 220     }
 221
 222     @SuppressWarnings({"checkstyle:IllegalThrows", "checkstyle:IllegalCatch"})
 223     @Test
 224     public void closeTest() throws Exception {
 225         final String testException = "TestException";
 226
 227         domBroker.setCloseable(() -> {
 228             throw new Exception(testException);
 229         });
 230
 231         try {
 232             domBroker.close();
 233         } catch (final Exception e) {
 234             assertTrue(e.getMessage().contains(testException));
 235         }
 236     }
 237
 238     static class CommitExecutorService extends ForwardingExecutorService {
 239
 240         ExecutorService delegate;
 241
 242         CommitExecutorService(final ExecutorService delegate) {
 243             this.delegate = delegate;
 244         }
 245
 246         @Override
 247         protected ExecutorService delegate() {
 248             return delegate;
 249         }
 250     }
 251 }