opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMTransactionFactory.java

   1 /*
   2  * Copyright (c) 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
   9 package org.opendaylight.controller.cluster.databroker;
  10
  11 import com.google.common.base.Preconditions;
  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.concurrent.atomic.AtomicIntegerFieldUpdater;
  17 import org.opendaylight.mdsal.common.api.CommitInfo;
  18 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  19 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  20 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  21 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  22 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
  23 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 public abstract class AbstractDOMTransactionFactory<T extends DOMStoreTransactionFactory> implements AutoCloseable {
  28     private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMTransactionFactory.class);
  29     @SuppressWarnings("rawtypes")
  30     private static final AtomicIntegerFieldUpdater<AbstractDOMTransactionFactory> UPDATER =
  31             AtomicIntegerFieldUpdater.newUpdater(AbstractDOMTransactionFactory.class, "closed");
  32
  33     private final Map<LogicalDatastoreType, T> storeTxFactories;
  34
  35     private volatile int closed = 0;
  36
  37     protected AbstractDOMTransactionFactory(final Map<LogicalDatastoreType, T> txFactories) {
  38         this.storeTxFactories = new EnumMap<>(txFactories);
  39     }
  40
  41     /**
  42      * Implementations must return unique identifier for each and every call of
  43      * this method.
  44      *
  45      * @return new Unique transaction identifier.
  46      */
  47     protected abstract Object newTransactionIdentifier();
  48
  49     /**
  50      * Submits a transaction asynchronously for commit.
  51      *
  52      * @param transaction the transaction to submit
  53      * @param cohorts the associated cohorts
  54      * @return a resulting Future
  55      */
  56     protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
  57             Collection<DOMStoreThreePhaseCommitCohort> cohorts);
  58
  59     /**
  60      * Creates a new read-only transaction.
  61      *
  62      * @return the transaction instance
  63      */
  64     public final DOMDataTreeReadTransaction newReadOnlyTransaction() {
  65         checkNotClosed();
  66
  67         return new DOMBrokerReadOnlyTransaction(newTransactionIdentifier(), storeTxFactories);
  68     }
  69
  70
  71     /**
  72      * Creates a new write-only transaction.
  73      *
  74      * @return the transaction instance
  75      */
  76     public final DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
  77         checkNotClosed();
  78
  79         return new DOMBrokerWriteOnlyTransaction(newTransactionIdentifier(), storeTxFactories, this);
  80     }
  81
  82
  83     /**
  84      * Creates a new read-write transaction.
  85      *
  86      * @return the transaction instance
  87      */
  88     public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
  89         checkNotClosed();
  90
  91         return new DOMBrokerReadWriteTransaction(newTransactionIdentifier(), storeTxFactories, this);
  92     }
  93
  94     /**
  95      * Convenience accessor of backing factories intended to be used only by
  96      * finalization of this class.
  97      *
  98      * <b>Note:</b>
  99      * Finalization of this class may want to access other functionality of
 100      * supplied Transaction factories.
 101      *
 102      * @return Map of backing transaction factories.
 103      */
 104     public final Map<LogicalDatastoreType, T> getTxFactories() {
 105         return storeTxFactories;
 106     }
 107
 108     /**
 109      * Checks if instance is not closed.
 110      *
 111      * @throws IllegalStateException If instance of this class was closed.
 112      *
 113      */
 114     protected final void checkNotClosed() {
 115         Preconditions.checkState(closed == 0, "Transaction factory was closed. No further operations allowed.");
 116     }
 117
 118     @Override
 119     public void close() {
 120         if (!UPDATER.compareAndSet(this, 0, 1)) {
 121             LOG.warn("Transaction factory was already closed", new Throwable());
 122         }
 123     }
 124 }