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.lang.invoke.MethodHandles;
  14 import java.lang.invoke.VarHandle;
  15 import java.util.EnumMap;
  16 import java.util.Map;
  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     private static final VarHandle CLOSED;
  30
  31     static {
  32         try {
  33             CLOSED = MethodHandles.lookup().findVarHandle(AbstractDOMTransactionFactory.class, "closed", boolean.class);
  34         } catch (NoSuchFieldException | IllegalAccessException e) {
  35             throw new ExceptionInInitializerError(e);
  36         }
  37     }
  38
  39     private final Map<LogicalDatastoreType, T> storeTxFactories;
  40
  41     private volatile boolean closed;
  42
  43     protected AbstractDOMTransactionFactory(final Map<LogicalDatastoreType, T> txFactories) {
  44         this.storeTxFactories = new EnumMap<>(txFactories);
  45     }
  46
  47     /**
  48      * Implementations must return unique identifier for each and every call of
  49      * this method.
  50      *
  51      * @return new Unique transaction identifier.
  52      */
  53     protected abstract Object newTransactionIdentifier();
  54
  55     /**
  56      * Submits a transaction asynchronously for commit.
  57      *
  58      * @param transaction the transaction to submit
  59      * @param cohort the associated cohort
  60      * @return a resulting Future
  61      */
  62     protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
  63             DOMStoreThreePhaseCommitCohort cohort);
  64
  65     /**
  66      * Creates a new read-only transaction.
  67      *
  68      * @return the transaction instance
  69      */
  70     public final DOMDataTreeReadTransaction newReadOnlyTransaction() {
  71         checkNotClosed();
  72
  73         return new DOMBrokerReadOnlyTransaction(newTransactionIdentifier(), storeTxFactories);
  74     }
  75
  76
  77     /**
  78      * Creates a new write-only transaction.
  79      *
  80      * @return the transaction instance
  81      */
  82     public final DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
  83         checkNotClosed();
  84
  85         return new DOMBrokerWriteOnlyTransaction(newTransactionIdentifier(), storeTxFactories, this);
  86     }
  87
  88
  89     /**
  90      * Creates a new read-write transaction.
  91      *
  92      * @return the transaction instance
  93      */
  94     public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
  95         checkNotClosed();
  96
  97         return new DOMBrokerReadWriteTransaction(newTransactionIdentifier(), storeTxFactories, this);
  98     }
  99
 100     /**
 101      * Convenience accessor of backing factories intended to be used only by
 102      * finalization of this class.
 103      *
 104      * <b>Note:</b>
 105      * Finalization of this class may want to access other functionality of
 106      * supplied Transaction factories.
 107      *
 108      * @return Map of backing transaction factories.
 109      */
 110     public final Map<LogicalDatastoreType, T> getTxFactories() {
 111         return storeTxFactories;
 112     }
 113
 114     /**
 115      * Checks if instance is not closed.
 116      *
 117      * @throws IllegalStateException If instance of this class was closed.
 118      *
 119      */
 120     protected final void checkNotClosed() {
 121         Preconditions.checkState(!closed, "Transaction factory was closed. No further operations allowed.");
 122     }
 123
 124     @Override
 125     public void close() {
 126         if (!CLOSED.compareAndSet(this, false, true)) {
 127             LOG.warn("Transaction factory was already closed", new Throwable());
 128         }
 129     }
 130 }