dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/AbstractDOMForwardedTransactionFactory.java

   1 /*
   2  * Copyright (c) 2014 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 com.google.common.base.Preconditions.checkState;
  11
  12 import com.google.common.util.concurrent.FluentFuture;
  13 import java.util.Collection;
  14 import java.util.EnumMap;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  18 import org.opendaylight.mdsal.common.api.CommitInfo;
  19 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  20 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
  21 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  22 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  23 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  24 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
  25 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
  26 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
  27 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
  28 import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  30 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  31
  32 /**
  33  * Abstract composite transaction factory.
  34  *
  35  *<p>
  36  * Provides an convenience common implementation for composite DOM Transactions, where subtransaction is identified by
  37  * {@link LogicalDatastoreType} type and implementation of subtransaction is provided by
  38  * {@link DOMStoreTransactionFactory}.
  39  *
  40  * <b>Note:</b>This class does not have thread-safe implementation of  {@link #close()}, implementation may allow
  41  *             accessing and allocating new transactions during closing this instance.
  42  *
  43  * @param <T> Type of {@link DOMStoreTransactionFactory} factory.
  44  */
  45 abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransactionFactory> implements AutoCloseable {
  46     @SuppressWarnings("rawtypes")
  47     private static final AtomicIntegerFieldUpdater<AbstractDOMForwardedTransactionFactory> UPDATER =
  48             AtomicIntegerFieldUpdater.newUpdater(AbstractDOMForwardedTransactionFactory.class, "closed");
  49     private final Map<LogicalDatastoreType, T> storeTxFactories;
  50     private volatile int closed = 0;
  51
  52     protected AbstractDOMForwardedTransactionFactory(final Map<LogicalDatastoreType, ? extends T> txFactories) {
  53         this.storeTxFactories = new EnumMap<>(txFactories);
  54     }
  55
  56     /**
  57      * Implementations must return unique identifier for each and every call of this method.
  58      *
  59      * @return new Unique transaction identifier.
  60      */
  61     protected abstract Object newTransactionIdentifier();
  62
  63     /**
  64      * User-supplied implementation of {@link DOMDataTreeWriteTransaction#commit()} for transaction.
  65      *
  66      *<p>
  67      * Callback invoked when {@link DOMDataTreeWriteTransaction#commit()} is invoked on transaction created by this
  68      * factory.
  69      *
  70      * @param transaction Transaction on which {@link DOMDataTreeWriteTransaction#commit()} was invoked.
  71      * @param cohorts Iteratable of cohorts for subtransactions associated with the transaction being committed.
  72      * @return a FluentFuture. if commit coordination on cohorts finished successfully, a CommitInfo is returned from
  73      *         the Future, On failure, the Future fails with a {@link TransactionCommitFailedException}.
  74      */
  75     protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
  76             Collection<DOMStoreThreePhaseCommitCohort> cohorts);
  77
  78     /**
  79      * Creates a new composite read-only transaction.
  80      *
  81      * <p>
  82      * Creates a new composite read-only transaction backed by one transaction per factory in {@link #getTxFactories()}.
  83      *
  84      * <p>
  85      * Subtransaction for reading is selected by supplied {@link LogicalDatastoreType} as parameter for
  86      * {@link DOMDataTreeReadTransaction#read(LogicalDatastoreType, YangInstanceIdentifier)}
  87      *
  88      * <p>
  89      * Id of returned transaction is retrieved via {@link #newTransactionIdentifier()}.
  90      *
  91      * @return New composite read-only transaction.
  92      */
  93     public final DOMDataTreeReadTransaction newReadOnlyTransaction() {
  94         checkNotClosed();
  95
  96         final Map<LogicalDatastoreType, DOMStoreReadTransaction> txns = new EnumMap<>(LogicalDatastoreType.class);
  97         for (final Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
  98             txns.put(store.getKey(), store.getValue().newReadOnlyTransaction());
  99         }
 100         return new DOMForwardedReadOnlyTransaction(newTransactionIdentifier(), txns);
 101     }
 102
 103     /**
 104      * Creates a new composite write-only transaction
 105      *
 106      * <p>
 107      * Creates a new composite write-only transaction backed by one write-only transaction per factory in
 108      * {@link #getTxFactories()}.
 109      *
 110      * <p>
 111      * Implementation of composite Write-only transaction is following:
 112      *
 113      * <ul>
 114      * <li>{@link DOMDataTreeWriteTransaction#put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
 115      *     - backing subtransaction is selected by {@link LogicalDatastoreType},
 116      *       {@link DOMStoreWriteTransaction#write(YangInstanceIdentifier, NormalizedNode)} is invoked on selected
 117      *       subtransaction.</li>
 118      * <li> {@link DOMDataTreeWriteTransaction#merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
 119      *      - backing subtransaction is selected by {@link LogicalDatastoreType},
 120      *        {@link DOMStoreWriteTransaction#merge(YangInstanceIdentifier, NormalizedNode)} is invoked on selected
 121      *        subtransaction.</li>
 122      * <li>{@link DOMDataTreeWriteTransaction#delete(LogicalDatastoreType, YangInstanceIdentifier)}
 123      *     - backing subtransaction is selected by {@link LogicalDatastoreType},
 124      *       {@link DOMStoreWriteTransaction#delete(YangInstanceIdentifier)} is invoked on selected subtransaction.
 125      * <li>{@link DOMDataTreeWriteTransaction#commit()} - results in invoking {@link DOMStoreWriteTransaction#ready()},
 126      *     gathering all resulting cohorts and then invoking finalized implementation callback
 127      *     {@link #commit(DOMDataTreeWriteTransaction, Collection)} with transaction which was committed and gathered
 128      *     results.</li>
 129      * </ul>
 130      *
 131      * <p>
 132      * Id of returned transaction is generated via {@link #newTransactionIdentifier()}.
 133      *
 134      * @return New composite write-only transaction associated with this factory.
 135      */
 136     public final DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
 137         checkNotClosed();
 138
 139         final Map<LogicalDatastoreType, DOMStoreWriteTransaction> txns = new EnumMap<>(LogicalDatastoreType.class);
 140         for (final Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
 141             txns.put(store.getKey(), store.getValue().newWriteOnlyTransaction());
 142         }
 143         return new DOMForwardedWriteTransaction<>(newTransactionIdentifier(), txns, this);
 144     }
 145
 146     /**
 147      * Creates a new composite read-write transaction.
 148      *
 149      * @return New composite read-write transaction associated with this factory.
 150      */
 151     public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
 152         checkNotClosed();
 153
 154         final Map<LogicalDatastoreType, DOMStoreReadWriteTransaction> txns = new EnumMap<>(LogicalDatastoreType.class);
 155         for (Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
 156             txns.put(store.getKey(), store.getValue().newReadWriteTransaction());
 157         }
 158         return new DOMForwardedReadWriteTransaction(newTransactionIdentifier(), txns, this);
 159     }
 160
 161     /**
 162      * Convenience accessor of backing factories intended to be used only by finalization of this class.
 163      *
 164      * <b>Note:</b> Finalization of this class may want to access other functionality of supplied Transaction factories.
 165      *
 166      * @return Map of backing transaction factories.
 167      */
 168     protected final Map<LogicalDatastoreType, T> getTxFactories() {
 169         return storeTxFactories;
 170     }
 171
 172     /**
 173      * Checks if instance is not closed.
 174      *
 175      * @throws IllegalStateException If instance of this class was closed.
 176      */
 177     protected final void checkNotClosed() {
 178         checkState(closed == 0, "Transaction factory was closed. No further operations allowed.");
 179     }
 180
 181     @Override
 182     public void close() {
 183         checkState(UPDATER.compareAndSet(this, 0, 1), "Transaction factory was already closed");
 184     }
 185 }