--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.dom.spi;
+
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.util.concurrent.FluentFuture;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.util.EnumMap;
+import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Abstract composite transaction factory.
+ *
+ * <p>
+ * Provides a convenience common implementation for composite DOM Transactions, where subtransaction is identified by
+ * {@link LogicalDatastoreType} type and implementation of subtransaction is provided by
+ * {@link DOMStoreTransactionFactory}.
+ *
+ * <b>Note:</b>This class does not have thread-safe implementation of {@link #close()}, implementation may allow
+ * accessing and allocating new transactions during closing this instance.
+ *
+ * @param <T> Type of {@link DOMStoreTransactionFactory} factory.
+ */
+abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransactionFactory> implements AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMForwardedTransactionFactory.class);
+ private static final VarHandle CLOSED;
+
+ static {
+ try {
+ CLOSED = MethodHandles.lookup()
+ .findVarHandle(AbstractDOMForwardedTransactionFactory.class, "closed", boolean.class);
+ } catch (NoSuchFieldException | IllegalAccessException e) {
+ throw new ExceptionInInitializerError(e);
+ }
+ }
+
+ private final Map<LogicalDatastoreType, T> storeTxFactories;
+
+ private volatile boolean closed;
+
+ protected AbstractDOMForwardedTransactionFactory(final Map<LogicalDatastoreType, ? extends T> txFactories) {
+ checkState(!txFactories.isEmpty(), "txFactories should not be empty.");
+ this.storeTxFactories = new EnumMap<>(txFactories);
+ }
+
+ /**
+ * Implementations must return unique identifier for each and every call of this method.
+ *
+ * @return new Unique transaction identifier.
+ */
+ protected abstract Object newTransactionIdentifier();
+
+ /**
+ * User-supplied implementation of {@link DOMDataTreeWriteTransaction#commit()} for transaction.
+ *
+ * <p>
+ * Callback invoked when {@link DOMDataTreeWriteTransaction#commit()} is invoked on transaction created by this
+ * factory.
+ *
+ * @param transaction Transaction on which {@link DOMDataTreeWriteTransaction#commit()} was invoked.
+ * @param cohort Subtransactions associated with the transaction being committed.
+ * @return a FluentFuture. if commit coordination on cohorts finished successfully, a CommitInfo is returned from
+ * the Future, On failure, the Future fails with a {@link TransactionCommitFailedException}.
+ */
+ protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
+ DOMStoreThreePhaseCommitCohort cohort);
+
+ /**
+ * Creates a new forwarded read-only transaction.
+ *
+ * <p>
+ * Creates a new read-only transaction backed by single read-only sub-transaction.
+ * Target datastore is determined dynamically on first usage.
+ *
+ * <p>
+ * Sub-transaction for reading is selected by supplied {@link LogicalDatastoreType} as parameter for
+ * {@link DOMDataTreeReadTransaction#read(LogicalDatastoreType, YangInstanceIdentifier)}
+ *
+ * <p>
+ * Identifier of returned transaction is retrieved via {@link #newTransactionIdentifier()}.
+ *
+ * @return New composite read-only transaction.
+ */
+ public final DOMDataTreeReadTransaction newReadOnlyTransaction() {
+ checkNotClosed();
+ return new DOMForwardedReadOnlyTransaction(newTransactionIdentifier(),
+ storeType -> requireTxFactory(storeType).newReadOnlyTransaction());
+ }
+
+ /**
+ * Creates a new forwarded write-only transaction
+ *
+ * <p>
+ * Creates a new write-only transaction backed by single write-only sub-transaction.
+ * Target datastore is determined dynamically on first usage.
+ *
+ * <p>
+ * Implementation of composite Write-only transaction is following:
+ *
+ * <ul>
+ * <li>{@link DOMDataTreeWriteTransaction#put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * - backing subtransaction is selected by {@link LogicalDatastoreType},
+ * {@link DOMStoreWriteTransaction#write(YangInstanceIdentifier, NormalizedNode)} is invoked on selected
+ * subtransaction.</li>
+ * <li> {@link DOMDataTreeWriteTransaction#merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * - backing subtransaction is selected by {@link LogicalDatastoreType},
+ * {@link DOMStoreWriteTransaction#merge(YangInstanceIdentifier, NormalizedNode)} is invoked on selected
+ * subtransaction.</li>
+ * <li>{@link DOMDataTreeWriteTransaction#delete(LogicalDatastoreType, YangInstanceIdentifier)}
+ * - backing subtransaction is selected by {@link LogicalDatastoreType},
+ * {@link DOMStoreWriteTransaction#delete(YangInstanceIdentifier)} is invoked on selected subtransaction.
+ * <li>{@link DOMDataTreeWriteTransaction#commit()} - results in invoking {@link DOMStoreWriteTransaction#ready()},
+ * gathering resulting cohort and then invoking finalized implementation callback
+ * {@link #commit(DOMDataTreeWriteTransaction, DOMStoreThreePhaseCommitCohort)} with transaction which
+ * was committed and gathered results.</li>
+ * </ul>
+ *
+ * <p>
+ * Identifier of returned transaction is generated via {@link #newTransactionIdentifier()}.
+ *
+ * @return New composite write-only transaction associated with this factory.
+ */
+ public final DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
+ checkNotClosed();
+ return new DOMForwardedWriteTransaction<>(newTransactionIdentifier(),
+ storeType -> requireTxFactory(storeType).newWriteOnlyTransaction(), this);
+ }
+
+ /**
+ * Creates a new forwarded read-write transaction.
+ *
+ * @return New forwarded read-write transaction associated with this factory.
+ */
+ public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ checkNotClosed();
+ return new DOMForwardedReadWriteTransaction(newTransactionIdentifier(),
+ storeType -> requireTxFactory(storeType).newReadWriteTransaction(), this);
+ }
+
+ /**
+ * Convenience accessor of backing factories intended to be used only by finalization of this class.
+ *
+ * <b>Note:</b> Finalization of this class may want to access other functionality of supplied Transaction factories.
+ *
+ * @return Map of backing transaction factories.
+ */
+ protected final Map<LogicalDatastoreType, T> getTxFactories() {
+ return storeTxFactories;
+ }
+
+ private @NonNull T requireTxFactory(final LogicalDatastoreType type) {
+ final var factory = storeTxFactories.get(requireNonNull(type));
+ if (factory == null) {
+ throw new IllegalArgumentException("Unsupported datastore type " + type);
+ }
+ return factory;
+ }
+
+ /**
+ * Checks if instance is not closed.
+ *
+ * @throws IllegalStateException If instance of this class was closed.
+ */
+ protected final void checkNotClosed() {
+ checkState(!closed, "Transaction factory was closed. No further operations allowed.");
+ }
+
+ @Override
+ public void close() {
+ if (!CLOSED.compareAndSet(this, false, true)) {
+ LOG.warn("Transaction factory was already closed", new Throwable());
+ }
+ }
+}
Code Review / mdsal.git / blobdiff