package org.opendaylight.mdsal.binding.api;
import org.opendaylight.mdsal.common.api.TransactionChain;
-
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
WriteTransaction newWriteOnlyTransaction();
+
+ @Override
+ ReadWriteTransaction newReadWriteTransaction();
}
@Override
WriteTransaction newWriteOnlyTransaction();
+ @Override
+ ReadWriteTransaction newReadWriteTransaction();
+
@Override
BindingTransactionChain createTransactionChain(TransactionChainListener listener);
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.binding.api;
+
+import com.google.common.annotations.Beta;
+import org.opendaylight.mdsal.common.api.AsyncReadWriteTransaction;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * A transaction that enables combined read/write capabilities.
+ *
+ * <p>
+ * For more information on usage and examples, please see the documentation in {@link AsyncReadWriteTransaction}.
+ */
+@Beta
+public interface ReadWriteTransaction extends ReadTransaction, WriteTransaction,
+ AsyncReadWriteTransaction<InstanceIdentifier<?>, DataObject> {
+}
abstract class BindingDOMAdapterBuilder<T extends BindingService> extends AdapterBuilder<T, DOMService> {
+ @FunctionalInterface
interface Factory<T extends BindingService> {
BindingDOMAdapterBuilder<T> newBuilder();
import org.opendaylight.mdsal.dom.api.DOMService;
public abstract class BindingDOMAdapterLoader extends AdapterLoader<BindingService, DOMService> {
-
-
- private static final Map<Class<?>,BindingDOMAdapterBuilder.Factory<?>> FACTORIES = ImmutableMap.<Class<?>,
- BindingDOMAdapterBuilder.Factory<?>>builder()
- .put(NotificationService.class,BindingDOMNotificationServiceAdapter.BUILDER_FACTORY)
- .put(NotificationPublishService.class,BindingDOMNotificationPublishServiceAdapter.BUILDER_FACTORY)
- .put(DataBroker.class,BindingDOMDataBrokerAdapter.BUILDER_FACTORY)
- .put(RpcConsumerRegistry.class,BindingDOMRpcServiceAdapter.BUILDER_FACTORY)
+ private static final Map<Class<?>,BindingDOMAdapterBuilder.Factory<?>> FACTORIES =
+ ImmutableMap.<Class<?>, BindingDOMAdapterBuilder.Factory<?>>builder()
+ .put(NotificationService.class, BindingDOMNotificationServiceAdapter.BUILDER_FACTORY)
+ .put(NotificationPublishService.class, BindingDOMNotificationPublishServiceAdapter.BUILDER_FACTORY)
+ .put(DataBroker.class, BindingDOMDataBrokerAdapter.BUILDER_FACTORY)
+ .put(RpcConsumerRegistry.class, BindingDOMRpcServiceAdapter.BUILDER_FACTORY)
.build();
private final BindingToNormalizedNodeCodec codec;
import org.opendaylight.mdsal.binding.api.DataTreeChangeService;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
DataBroker, DataTreeChangeService {
- static final Factory<DataBroker> BUILDER_FACTORY = new BindingDOMAdapterBuilder.Factory<DataBroker>() {
-
- @Override
- public BindingDOMAdapterBuilder<DataBroker> newBuilder() {
- return new Builder();
- }
-
- };
+ static final Factory<DataBroker> BUILDER_FACTORY = Builder::new;
private final DataTreeChangeService treeChangeService;
public BindingDOMDataBrokerAdapter(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec) {
@Override
public ReadTransaction newReadOnlyTransaction() {
- return new BindingDOMReadTransactionAdapter(getDelegate().newReadOnlyTransaction(),getCodec());
+ return new BindingDOMReadTransactionAdapter(getDelegate().newReadOnlyTransaction(), getCodec());
}
@Override
public WriteTransaction newWriteOnlyTransaction() {
- return new BindingDOMWriteTransactionAdapter<>(getDelegate().newWriteOnlyTransaction(),getCodec());
+ return new BindingDOMWriteTransactionAdapter<>(getDelegate().newWriteOnlyTransaction(), getCodec());
+ }
+
+ @Override
+ public ReadWriteTransaction newReadWriteTransaction() {
+ return new BindingDOMReadWriteTransactionAdapter(getDelegate().newReadWriteTransaction(), getCodec());
}
@Override
}
return treeChangeService.registerDataTreeChangeListener(treeId, listener);
}
-
}
public class BindingDOMNotificationPublishServiceAdapter implements NotificationPublishService, AutoCloseable {
- static final Factory<NotificationPublishService> BUILDER_FACTORY
- = new BindingDOMAdapterBuilder.Factory<NotificationPublishService>() {
-
- @Override
- public BindingDOMAdapterBuilder<NotificationPublishService> newBuilder() {
- return new Builder();
- }
-
- };
+ static final Factory<NotificationPublishService> BUILDER_FACTORY = Builder::new;
private final BindingToNormalizedNodeCodec codecRegistry;
private final DOMNotificationPublishService domPublishService;
public class BindingDOMNotificationServiceAdapter implements NotificationService, AutoCloseable {
- public static final Factory<NotificationService> BUILDER_FACTORY = new Factory<NotificationService>() {
+ public static final Factory<NotificationService> BUILDER_FACTORY = Builder::new;
- @Override
- public BindingDOMAdapterBuilder<NotificationService> newBuilder() {
- return new Builder();
- }
-
- };
private final BindingNormalizedNodeSerializer codec;
private final DOMNotificationService domNotifService;
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.binding.dom.adapter;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+class BindingDOMReadWriteTransactionAdapter extends BindingDOMWriteTransactionAdapter<DOMDataTreeReadWriteTransaction>
+ implements ReadWriteTransaction {
+
+ BindingDOMReadWriteTransactionAdapter(DOMDataTreeReadWriteTransaction delegateTx,
+ BindingToNormalizedNodeCodec codec) {
+ super(delegateTx, codec);
+ }
+
+ @Override
+ public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(LogicalDatastoreType store,
+ InstanceIdentifier<T> path) {
+ return doRead(getDelegate(),store, path);
+ }
+
+ @Override
+ public void close() {
+ }
+}
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.mdsal.binding.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.TransactionChain;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
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.api.DOMTransactionChain;
import org.opendaylight.yangtools.concepts.Delegator;
};
}
+ @Override
+ public ReadWriteTransaction newReadWriteTransaction() {
+ final DOMDataTreeReadWriteTransaction delegateTx = delegate.newReadWriteTransaction();
+ return new BindingDOMReadWriteTransactionAdapter(delegateTx, codec) {
+
+ @Override
+ public CheckedFuture<Void, TransactionCommitFailedException> submit() {
+ return listenForFailure(this,super.submit());
+ }
+
+ };
+ }
+
private <T, F extends ListenableFuture<T>> F listenForFailure(final WriteTransaction tx, final F future) {
Futures.addCallback(future, new FutureCallback<T>() {
@Override
bindingListener.onTransactionChainSuccessful(BindingDOMTransactionChainAdapter.this);
}
}
-
}
import org.opendaylight.mdsal.binding.javav2.dom.adapter.spi.builder.BindingDOMAdapterBuilder;
import org.opendaylight.mdsal.binding.javav2.dom.adapter.spi.builder.BindingDOMAdapterBuilder.Factory;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
+import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
+import org.opendaylight.mdsal.common.api.AsyncReadWriteTransaction;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
return new BindingDOMWriteTransactionAdapter<>(getDelegate().newWriteOnlyTransaction(), getCodec());
}
+ @Override
+ public AsyncReadWriteTransaction<InstanceIdentifier<?>, TreeNode> newReadWriteTransaction() {
+ // TODO - placeholder for now
+ throw new UnsupportedOperationException();
+ }
+
@Override
public BindingTransactionChain createTransactionChain(final TransactionChainListener listener) {
return new BindingDOMTransactionChainAdapter(getDelegate(), getCodec(), listener);
import org.opendaylight.mdsal.binding.javav2.api.ReadTransaction;
import org.opendaylight.mdsal.binding.javav2.api.WriteTransaction;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
+import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
+import org.opendaylight.mdsal.common.api.AsyncReadWriteTransaction;
import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.TransactionChain;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
};
}
+ @Override
+ public AsyncReadWriteTransaction<InstanceIdentifier<?>, TreeNode> newReadWriteTransaction() {
+ // TODO - placeholder for now
+ throw new UnsupportedOperationException();
+ }
+
private <T, F extends ListenableFuture<T>> F listenForFailure(final WriteTransaction tx, final F future) {
Futures.addCallback(future, new FutureCallback<T>() {
@Override
@Override
AsyncWriteTransaction<P, D> newWriteOnlyTransaction();
+
+ @Override
+ AsyncReadWriteTransaction<P, D> newReadWriteTransaction();
}
*/
AsyncWriteTransaction<P, D> newWriteOnlyTransaction();
+ /**
+ * Allocates new read-write transaction which provides a mutable view of the data tree.
+ *
+ * <p>
+ * Preconditions for mutation of data tree are captured from the snapshot of data tree state, when the transaction
+ * is allocated. If data was changed during transaction in an incompatible way then the commit of this transaction
+ * will fail. See {@link AsyncWriteTransaction#submit()} for more details about conflicting and not-conflicting
+ * changes and failure scenarios.
+ *
+ * @return new read-write transaction
+ */
+ AsyncReadWriteTransaction<P, D> newReadWriteTransaction();
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.common.api;
+
+import org.opendaylight.yangtools.concepts.Path;
+
+/**
+ * Transaction enabling a client to have combined read/write capabilities.
+ *
+ * <p>
+ * The initial state of the write transaction is stable snapshot of current data tree
+ * state captured when transaction was created and it's state and underlying
+ * data tree are not affected by other concurrently running transactions.
+ *
+ * <p>
+ * Write transactions are isolated from other concurrent write transactions. All
+ * writes are local to the transaction and represents only a proposal of state
+ * change for data tree and it is not visible to any other concurrently running
+ * transactions.
+ *
+ * <p>
+ * Applications publish the changes proposed in the transaction by calling {@link #submit}
+ * on the transaction. This seals the transaction
+ * (preventing any further writes using this transaction) and submits it to be
+ * processed and applied to global conceptual data tree.
+ *
+ * <p>
+ * The transaction commit may fail due to a concurrent transaction modifying and committing data in
+ * an incompatible way. See {@link #submit()} for more concrete commit failure examples.
+ *
+ * <b>Implementation Note:</b> This interface is not intended to be implemented
+ * by users of MD-SAL, but only to be consumed by them.
+ *
+ * <h2>Examples</h2>
+ *
+ * <h3>Transaction local state</h3>
+ *
+ * <p>
+ * Let's assume initial state of data tree for <code>PATH</code> is <code>A</code>
+ * .
+ * <pre>
+ * txWrite = broker.newReadWriteTransaction(); // concurrent write transaction
+ *
+ * txWrite.read(OPERATIONAL,PATH).get() // will return Optional containing A
+ * txWrite.put(OPERATIONAL,PATH,B); // writes B to PATH
+ * txWrite.read(OPERATIONAL,PATH).get() // will return Optional Containing B
+ *
+ * txWrite.commit().get(); // data tree is updated, PATH contains B
+ *
+ * tx1afterCommit = broker.newReadOnlyTransaction(); // read Transaction is snapshot of new state
+ * tx1afterCommit.read(OPERATIONAL,PATH).get(); // returns Optional containing B
+ * </pre>
+ *
+ * <p>
+ * As you could see read-write transaction provides capabilities as
+ * {@link AsyncWriteTransaction} but also allows for reading proposed changes as
+ * if they already happened.
+ *
+ * <h3>Transaction isolation (read transaction, read-write transaction)</h3> Let
+ * assume initial state of data tree for <code>PATH</code> is <code>A</code>.
+ *
+ * <pre>
+ * txRead = broker.newReadOnlyTransaction(); // read Transaction is snapshot of data
+ * txWrite = broker.newReadWriteTransaction(); // concurrent write transaction
+ *
+ * txRead.read(OPERATIONAL,PATH).get(); // will return Optional containing A
+ * txWrite.read(OPERATIONAL,PATH).get() // will return Optional containing A
+ *
+ * txWrite.put(OPERATIONAL,PATH,B); // writes B to PATH
+ * txWrite.read(OPERATIONAL,PATH).get() // will return Optional Containing B
+ *
+ * txRead.read(OPERATIONAL,PATH).get(); // concurrent read transaction still returns
+ * // Optional containing A
+ *
+ * txWrite.commit().get(); // data tree is updated, PATH contains B
+ * txRead.read(OPERATIONAL,PATH).get(); // still returns Optional containing A
+ *
+ * tx1afterCommit = broker.newReadOnlyTransaction(); // read Transaction is snapshot of new state
+ * tx1afterCommit.read(OPERATIONAL,PATH).get(); // returns Optional containing B
+ * </pre>
+ *
+ * <h3>Transaction isolation (2 concurrent read-write transactions)</h3> Let
+ * assume initial state of data tree for <code>PATH</code> is <code>A</code>.
+ *
+ * <pre>
+ * tx1 = broker.newReadWriteTransaction(); // read Transaction is snapshot of data
+ * tx2 = broker.newReadWriteTransaction(); // concurrent write transaction
+ *
+ * tx1.read(OPERATIONAL,PATH).get(); // will return Optional containing A
+ * tx2.read(OPERATIONAL,PATH).get() // will return Optional containing A
+ *
+ * tx2.put(OPERATIONAL,PATH,B); // writes B to PATH
+ * tx2.read(OPERATIONAL,PATH).get() // will return Optional Containing B
+ *
+ * tx1.read(OPERATIONAL,PATH).get(); // tx1 read-write transaction still sees Optional
+ * // containing A since is isolated from tx2
+ * tx1.put(OPERATIONAL,PATH,C); // writes C to PATH
+ * tx1.read(OPERATIONAL,PATH).get() // will return Optional Containing C
+ *
+ * tx2.read(OPERATIONAL,PATH).get() // tx2 read-write transaction still sees Optional
+ * // containing B since is isolated from tx1
+ *
+ * tx2.commit().get(); // data tree is updated, PATH contains B
+ * tx1.read(OPERATIONAL,PATH).get(); // still returns Optional containing C since is isolated from tx2
+ *
+ * tx1afterCommit = broker.newReadOnlyTransaction(); // read Transaction is snapshot of new state
+ * tx1afterCommit.read(OPERATIONAL,PATH).get(); // returns Optional containing B
+ *
+ * tx1.commit() // Will fail with OptimisticLockFailedException
+ * // which means concurrent transaction changed the same PATH
+ *
+ * </pre>
+ *
+ * <p>
+ * <b>Note:</b> examples contains blocking calls on future only to illustrate
+ * that action happened after other asynchronous action. Use of blocking call
+ * {@link com.google.common.util.concurrent.ListenableFuture#get()} is discouraged for most uses and you should
+ * use
+ * {@link com.google.common.util.concurrent.Futures#addCallback(com.google.common.util.concurrent.ListenableFuture,
+ * com.google.common.util.concurrent.FutureCallback)}
+ * or other functions from {@link com.google.common.util.concurrent.Futures} to
+ * register more specific listeners.
+ *
+ * @see AsyncReadTransaction
+ * @see AsyncWriteTransaction
+ *
+ * @param <P>
+ * Type of path (subtree identifier), which represents location in
+ * tree
+ * @param <D>
+ * Type of data (payload), which represents data payload
+ */
+public interface AsyncReadWriteTransaction<P extends Path<P>, D> extends AsyncReadTransaction<P, D>,
+ AsyncWriteTransaction<P, D> {
+
+}
@Override
AsyncWriteTransaction<P, D> newWriteOnlyTransaction();
+ /**
+ * Create a new read-write transaction which will continue the chain.
+ *
+ * <p>
+ * The previous write transaction has to be either SUBMITTED
+ * ({@link AsyncWriteTransaction#submit submit} was invoked) or CANCELLED
+ * ({@link #close close} was invoked).
+ *
+ * <p>
+ * The returned read-write transaction presents an isolated view of the data if the previous
+ * write transaction was successful - in other words, this read-write transaction will see the
+ * state changes made by the previous write transaction in the chain. However, state which
+ * was introduced by other transactions outside this transaction chain after creation of
+ * the previous transaction is not visible.
+ *
+ * <p>
+ * Committing this read-write transaction using {@link AsyncWriteTransaction#submit submit}
+ * will submit the state changes in this transaction to be visible to any subsequent
+ * transaction in this chain and also to any transaction outside this chain.
+ *
+ * @return New transaction in the chain.
+ * @throws IllegalStateException
+ * if the previous transaction was not SUBMITTED or CANCELLED.
+ * @throws TransactionChainClosedException
+ * if the chain has been closed.
+ */
+ @Override
+ AsyncReadWriteTransaction<P, D> newReadWriteTransaction();
+
@Override
void close();
}
@Override
DOMDataTreeWriteTransaction newWriteOnlyTransaction();
+ @Override
+ DOMDataTreeReadWriteTransaction newReadWriteTransaction();
+
@Override
DOMTransactionChain createTransactionChain(TransactionChainListener listener);
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.api;
+
+import org.opendaylight.mdsal.common.api.AsyncReadWriteTransaction;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+/**
+ * A transaction that provides read/write access to a logical data store.
+ *
+ * <p>
+ * For more information on usage and examples, please see the documentation in {@link AsyncReadWriteTransaction}.
+ */
+public interface DOMDataTreeReadWriteTransaction extends DOMDataTreeReadTransaction, DOMDataTreeWriteTransaction,
+ AsyncReadWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
+}
@Override
DOMDataTreeWriteTransaction newWriteOnlyTransaction();
+ @Override
+ DOMDataTreeReadWriteTransaction newReadWriteTransaction();
}
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.DOMStoreReadTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
return new DOMForwardedWriteTransaction<>(newTransactionIdentifier(), txns, this);
}
+ /**
+ * Creates a new composite read-write transaction.
+ *
+ * @return New composite read-write transaction associated with this factory.
+ */
+ public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ checkNotClosed();
+
+ final Map<LogicalDatastoreType, DOMStoreReadWriteTransaction> txns = new EnumMap<>(LogicalDatastoreType.class);
+ for (Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
+ txns.put(store.getKey(), store.getValue().newReadWriteTransaction());
+ }
+ return new DOMForwardedReadWriteTransaction(newTransactionIdentifier(), txns, this);
+ }
+
/**
* Convenience accessor of backing factories intended to be used only by
* finalization of this class.
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.broker;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Map;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+/**
+ * Read-Write Transaction, which is composed of several
+ * {@link DOMStoreReadWriteTransaction} transactions. Subtransaction is selected by
+ * {@link LogicalDatastoreType} type parameter in:
+ *
+ * <ul>
+ * <li>{@link #read(LogicalDatastoreType, YangInstanceIdentifier)}
+ * <li>{@link #put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * <li>{@link #delete(LogicalDatastoreType, YangInstanceIdentifier)}
+ * <li>{@link #merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * </ul>
+ *
+ * <p>
+ * {@link #submit()} will result in invocation of
+ * {@link DOMDataCommitImplementation#submit(org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction, Iterable)}
+ * invocation with all
+ * {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort} for
+ * underlying transactions.
+ */
+final class DOMForwardedReadWriteTransaction extends DOMForwardedWriteTransaction<DOMStoreReadWriteTransaction>
+ implements DOMDataTreeReadWriteTransaction {
+
+ protected DOMForwardedReadWriteTransaction(final Object identifier,
+ final Map<LogicalDatastoreType, DOMStoreReadWriteTransaction> backingTxs,
+ final AbstractDOMForwardedTransactionFactory<?> commitImpl) {
+ super(identifier, backingTxs, commitImpl);
+ }
+
+ @Override
+ public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
+ return getSubtransaction(store).read(path);
+ }
+
+ @Override
+ public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
+ return getSubtransaction(store).exists(path);
+ }
+
+ @Override
+ public void close() {
+ closeSubtransactions();
+ }
+}
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
return new ShardedDOMWriteTransactionAdapter(newTransactionIdentifier(), service);
}
+ @Override
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ return new ShardedDOMReadWriteTransactionAdapter(newTransactionIdentifier(), service);
+ }
+
@Override
public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
return new ShardedDOMTransactionChainAdapter(newChainIdentifier(), service, listener);
private Object newChainIdentifier() {
return "DOM-CHAIN-" + chainNum;
}
-
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.broker;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class ShardedDOMReadWriteTransactionAdapter extends ShardedDOMWriteTransactionAdapter
+ implements DOMDataTreeReadWriteTransaction {
+
+ private final ShardedDOMReadTransactionAdapter readAdapter;
+
+ ShardedDOMReadWriteTransactionAdapter(Object identifier, DOMDataTreeService transactionDelegator) {
+ super(identifier, transactionDelegator);
+ readAdapter = new ShardedDOMReadTransactionAdapter(identifier, transactionDelegator);
+ }
+
+ @Override
+ public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
+ YangInstanceIdentifier path) {
+ return readAdapter.read(store, path);
+ }
+
+ @Override
+ public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ return readAdapter.exists(store, path);
+ }
+
+ @Override
+ public void close() {
+ readAdapter.close();
+ }
+
+ ShardedDOMReadTransactionAdapter getReadAdapter() {
+ return readAdapter;
+ }
+}
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducerException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
return writeTx;
}
+ @Override
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ checkRunning();
+ checkWriteTxClosed();
+ checkReadTxClosed();
+ ShardedDOMReadWriteTransactionAdapter adapter = new ShardedDOMReadWriteTransactionAdapter(
+ newTransactionIdentifier(), cachedDataTreeService);
+ TransactionChainReadWriteTransaction readWriteTx = new TransactionChainReadWriteTransaction(
+ newTransactionIdentifier(), adapter, adapter.getReadAdapter(), writeTxSubmitFuture, this);
+
+ writeTx = readWriteTx;
+ return readWriteTx;
+ }
+
@Override
public void close() {
if (finished) {
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communications 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.broker;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+class TransactionChainReadWriteTransaction extends TransactionChainWriteTransaction
+ implements DOMDataTreeReadWriteTransaction {
+
+ private final TransactionChainReadTransaction readTx;
+
+ TransactionChainReadWriteTransaction(final Object identifier,
+ final DOMDataTreeReadWriteTransaction delegateWriteTx, final DOMDataTreeReadTransaction delegateReadTx,
+ final ListenableFuture<Void> previousWriteTxFuture, final ShardedDOMTransactionChainAdapter txChain) {
+ super(identifier, delegateWriteTx, txChain);
+ readTx = new TransactionChainReadTransaction(identifier, delegateReadTx, previousWriteTxFuture, txChain);
+ }
+
+ @Override
+ public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
+ YangInstanceIdentifier path) {
+ return readTx.read(store, path);
+ }
+
+ @Override
+ public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ return readTx.exists(store, path);
+ }
+
+ @Override
+ public void close() {
+ }
+}
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
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.api.DOMTransactionChain;
return delegate().newWriteOnlyTransaction();
}
+ @Override
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ return delegate().newReadWriteTransaction();
+ }
+
@Override
public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
return delegate().createTransactionChain(listener);
import com.google.common.collect.ForwardingObject;
import javax.annotation.Nonnull;
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.api.DOMTransactionChain;
public DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
return delegate().newWriteOnlyTransaction();
}
+
+ @Override
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
+ return delegate().newReadWriteTransaction();
+ }
}
protected DOMTransactionChain delegate() {
return domTransactionChain;
}
-}
\ No newline at end of file
+}
Code Review / mdsal.git / commitdiff