* 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.controller.cluster.databroker;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.collect.ImmutableMap;
-import java.util.Collections;
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap.Builder;
import java.util.EnumMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
-import org.opendaylight.controller.sal.core.spi.data.DOMStore;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTreeChangePublisher;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
+import org.opendaylight.mdsal.dom.spi.PingPongMergingDOMDataBroker;
+import org.opendaylight.mdsal.dom.spi.store.DOMStore;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-abstract class AbstractDOMBroker extends AbstractDOMTransactionFactory<DOMStore>
- implements DOMDataBroker {
+public abstract class AbstractDOMBroker extends AbstractDOMTransactionFactory<DOMStore>
+ implements PingPongMergingDOMDataBroker {
private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMBroker.class);
private final AtomicLong txNum = new AtomicLong();
private final AtomicLong chainNum = new AtomicLong();
- private final Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> extensions;
+ private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
+
private volatile AutoCloseable closeable;
protected AbstractDOMBroker(final Map<LogicalDatastoreType, DOMStore> datastores) {
super(datastores);
- boolean treeChange = true;
- for (DOMStore ds : datastores.values()) {
- if (!(ds instanceof DOMStoreTreeChangePublisher)) {
- treeChange = false;
- break;
- }
- }
-
- if (treeChange) {
- extensions = ImmutableMap.of(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
+ Builder<DOMDataBrokerExtension> extBuilder = ImmutableClassToInstanceMap.builder();
+ if (isSupported(datastores, DOMStoreTreeChangePublisher.class)) {
+ extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
@Override
public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
final DOMDataTreeIdentifier treeId, final L listener) {
- DOMStore publisher = getTxFactories().get(treeId.getDatastoreType());
- checkState(publisher != null, "Requested logical data store is not available.");
-
- return ((DOMStoreTreeChangePublisher) publisher).registerTreeChangeListener(
+ DOMStore store = getDOMStore(treeId.getDatastoreType());
+ return ((DOMStoreTreeChangePublisher) store).registerTreeChangeListener(
treeId.getRootIdentifier(), listener);
}
});
- } else {
- extensions = Collections.emptyMap();
}
+
+ if (isSupported(datastores, DOMDataTreeCommitCohortRegistry.class)) {
+ extBuilder.put(DOMDataTreeCommitCohortRegistry.class, new DOMDataTreeCommitCohortRegistry() {
+ @Override
+ public <T extends DOMDataTreeCommitCohort> DOMDataTreeCommitCohortRegistration<T> registerCommitCohort(
+ final DOMDataTreeIdentifier path, final T cohort) {
+ DOMStore store = getDOMStore(path.getDatastoreType());
+ return ((DOMDataTreeCommitCohortRegistry) store).registerCommitCohort(path, cohort);
+ }
+ });
+ }
+
+ extensions = extBuilder.build();
+ }
+
+ private static boolean isSupported(final Map<LogicalDatastoreType, DOMStore> datastores,
+ final Class<?> expDOMStoreInterface) {
+ return datastores.values().stream().allMatch(expDOMStoreInterface::isInstance);
}
public void setCloseable(final AutoCloseable closeable) {
}
@Override
- public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store,
- final YangInstanceIdentifier path, final DOMDataChangeListener listener,
- final DataChangeScope triggeringScope) {
- DOMStore potentialStore = getTxFactories().get(store);
- checkState(potentialStore != null, "Requested logical data store is not available.");
- return potentialStore.registerChangeListener(path, listener, triggeringScope);
- }
-
- @Override
- public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
+ public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
return extensions;
}
@Override
- public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
checkNotClosed();
final Map<LogicalDatastoreType, DOMStoreTransactionChain> backingChains =
backingChains);
return new DOMBrokerTransactionChain(chainId, backingChains, this, listener);
}
+
+ private DOMStore getDOMStore(final LogicalDatastoreType type) {
+ DOMStore store = getTxFactories().get(type);
+ checkState(store != null, "Requested logical data store is not available.");
+ return store;
+ }
}