2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.md.sal.dom.broker.impl;
11 import java.util.Map.Entry;
13 import javax.annotation.concurrent.GuardedBy;
15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
16 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
17 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
18 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
19 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
20 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
21 import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionFactory;
22 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
23 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
24 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
26 import com.google.common.base.Preconditions;
27 import com.google.common.collect.ImmutableMap;
31 * Abstract composite transaction factory.
33 * Provides an convenience common implementation for composite DOM Transactions,
34 * where subtransaction is identified by {@link LogicalDatastoreType} type and
35 * implementation of subtransaction is provided by
36 * {@link DOMStoreTransactionFactory}.
38 * <b>Note:</b>This class does not have thread-safe implementation of {@link #close()},
39 * implementation may allow accessing and allocating new transactions during closing
43 * Type of {@link DOMStoreTransactionFactory} factory.
45 public abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransactionFactory> implements DOMDataCommitImplementation, AutoCloseable {
47 private final ImmutableMap<LogicalDatastoreType, T> storeTxFactories;
49 private boolean closed;
51 protected AbstractDOMForwardedTransactionFactory(final Map<LogicalDatastoreType, ? extends T> txFactories) {
52 this.storeTxFactories = ImmutableMap.copyOf(txFactories);
56 * Implementations must return unique identifier for each and every call of
59 * @return new Unique transaction identifier.
61 protected abstract Object newTransactionIdentifier();
64 * Creates a new composite read-only transaction
66 * Creates a new composite read-only transaction backed by one transaction
67 * per factory in {@link #getTxFactories()}.
69 * Subtransaction for reading is selected by supplied
70 * {@link LogicalDatastoreType} as parameter for
71 * {@link DOMDataReadTransaction#read(LogicalDatastoreType, InstanceIdentifier)}
74 * Id of returned transaction is retrieved via
75 * {@link #newTransactionIdentifier()}.
77 * @return New composite read-only transaction.
79 public DOMDataReadTransaction newReadOnlyTransaction() {
81 ImmutableMap.Builder<LogicalDatastoreType, DOMStoreReadTransaction> builder = ImmutableMap.builder();
82 for (Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
83 builder.put(store.getKey(), store.getValue().newReadOnlyTransaction());
85 return new DOMForwardedReadOnlyTransaction(newTransactionIdentifier(), builder.build());
91 * Creates a new composite write-only transaction
94 * Creates a new composite write-only transaction backed by one write-only
95 * transaction per factory in {@link #getTxFactories()}.
98 * Implementation of composite Write-only transaction is following:
102 * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
103 * - backing subtransaction is selected by {@link LogicalDatastoreType},
104 * {@link DOMStoreWriteTransaction#write(InstanceIdentifier, NormalizedNode)}
105 * is invoked on selected subtransaction.
107 * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
108 * - backing subtransaction is selected by {@link LogicalDatastoreType},
109 * {@link DOMStoreWriteTransaction#merge(InstanceIdentifier, NormalizedNode)}
110 * is invoked on selected subtransaction.
112 * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, InstanceIdentifier)
113 * - backing subtransaction is selected by {@link LogicalDatastoreType},
114 * {@link DOMStoreWriteTransaction#delete(InstanceIdentifier)} is invoked on
115 * selected subtransaction.
116 * <li> {@link DOMDataWriteTransaction#commit()} - results in invoking
117 * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
118 * and then invoking finalized implementation callback
119 * {@link #commit(DOMDataWriteTransaction, Iterable)} with transaction which
120 * was commited and gathered results.
123 * Id of returned transaction is generated via
124 * {@link #newTransactionIdentifier()}.
126 * @return New composite write-only transaction associated with this
129 public DOMDataWriteTransaction newWriteOnlyTransaction() {
131 ImmutableMap.Builder<LogicalDatastoreType, DOMStoreWriteTransaction> builder = ImmutableMap.builder();
132 for (Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
133 builder.put(store.getKey(), store.getValue().newWriteOnlyTransaction());
135 return new DOMForwardedWriteTransaction<DOMStoreWriteTransaction>(newTransactionIdentifier(), builder.build(),
140 * Creates a new composite write-only transaction
143 * Creates a new composite write-only transaction backed by one write-only
144 * transaction per factory in {@link #getTxFactories()}.
146 * Implementation of composite Write-only transaction is following:
150 * {@link DOMDataWriteTransaction#read(LogicalDatastoreType, InstanceIdentifier)}
151 * - backing subtransaction is selected by {@link LogicalDatastoreType},
152 * {@link DOMStoreWriteTransaction#read(InstanceIdentifier)} is invoked on
153 * selected subtransaction.
155 * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
156 * - backing subtransaction is selected by {@link LogicalDatastoreType},
157 * {@link DOMStoreWriteTransaction#write(InstanceIdentifier, NormalizedNode)}
158 * is invoked on selected subtransaction.
160 * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
161 * - backing subtransaction is selected by {@link LogicalDatastoreType},
162 * {@link DOMStoreWriteTransaction#merge(InstanceIdentifier, NormalizedNode)}
163 * is invoked on selected subtransaction.
165 * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, InstanceIdentifier)
166 * - backing subtransaction is selected by {@link LogicalDatastoreType},
167 * {@link DOMStoreWriteTransaction#delete(InstanceIdentifier)} is invoked on
168 * selected subtransaction.
169 * <li> {@link DOMDataWriteTransaction#commit()} - results in invoking
170 * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
171 * and then invoking finalized implementation callback
172 * {@link #commit(DOMDataWriteTransaction, Iterable)} with transaction which
173 * was commited and gathered results.
177 * Id of returned transaction is generated via
178 * {@link #newTransactionIdentifier()}.
180 * @return New composite read-write transaction associated with this
184 public DOMDataReadWriteTransaction newReadWriteTransaction() {
186 ImmutableMap.Builder<LogicalDatastoreType, DOMStoreReadWriteTransaction> builder = ImmutableMap.builder();
187 for (Entry<LogicalDatastoreType, T> store : storeTxFactories.entrySet()) {
188 builder.put(store.getKey(), store.getValue().newReadWriteTransaction());
190 return new DOMForwardedReadWriteTransaction(newTransactionIdentifier(), builder.build(), this);
194 * Convenience accessor of backing factories intended to be used only by
195 * finalization of this class.
198 * Finalization of this class may want to access other functionality of
199 * supplied Transaction factories.
201 * @return Map of backing transaction factories.
203 protected final Map<LogicalDatastoreType, T> getTxFactories() {
204 return storeTxFactories;
209 * Checks if instance is not closed.
211 * @throws IllegalStateException If instance of this class was closed.
215 protected synchronized void checkNotClosed() {
216 Preconditions.checkState(!closed,"Transaction factory was closed. No further operations allowed.");
221 public synchronized void close() {