org.opendaylight.controller.cluster.databroker

Class ConcurrentDOMDataBroker

java.lang.Object

org.opendaylight.controller.cluster.databroker.AbstractDOMTransactionFactory<DOMStore>

org.opendaylight.controller.cluster.databroker.ConcurrentDOMDataBroker

All Implemented Interfaces:

AutoCloseable, AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>, AsyncDataTransactionFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>, TransactionChainFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>, DOMDataBroker, DOMExtensibleService<DOMDataBroker,DOMDataBrokerExtension>, DOMService, BrokerService

@Beta
public class ConcurrentDOMDataBroker
extends AbstractDOMTransactionFactory<DOMStore>

ConcurrentDOMDataBroker commits transactions concurrently. The 3 commit phases (canCommit, preCommit, and commit) are performed serially and non-blocking (ie async) per transaction but multiple transaction commits can run concurrent.

Author:

Thomas Pantelis

Nested Class Summary

Nested classes/interfaces inherited from interface org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker

AsyncDataBroker.DataChangeScope

Constructor Summary

Constructors

Constructor and Description
ConcurrentDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores, Executor listenableFutureExecutor)
ConcurrentDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores, Executor listenableFutureExecutor, org.opendaylight.yangtools.util.DurationStatisticsTracker commitStatsTracker)

Method Summary

Modifier and Type	Method and Description
void	close()
DOMTransactionChain	createTransactionChain(TransactionChainListener listener) Create a new transaction chain.
org.opendaylight.yangtools.util.DurationStatisticsTracker	getCommitStatsTracker()
Map<Class<? extends DOMDataBrokerExtension>,DOMDataBrokerExtension>	getSupportedExtensions() Return a map of currently-supported extensions, along with accessor services which provide access to the specific functionality bound to this service.
protected Object	newTransactionIdentifier() Implementations must return unique identifier for each and every call of this method.
org.opendaylight.yangtools.concepts.ListenerRegistration<DOMDataChangeListener>	registerDataChangeListener(LogicalDatastoreType store, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path, DOMDataChangeListener listener, AsyncDataBroker.DataChangeScope triggeringScope) Registers a AsyncDataChangeListener to receive notifications when data changes under a given path in the conceptual data tree.
void	setCloseable(AutoCloseable closeable)
protected com.google.common.util.concurrent.CheckedFuture<Void,TransactionCommitFailedException>	submit(DOMDataWriteTransaction transaction, Collection<DOMStoreThreePhaseCommitCohort> cohorts) Submits a transaction asynchronously for commit.
String	toString()

Methods inherited from class org.opendaylight.controller.cluster.databroker.AbstractDOMTransactionFactory

checkNotClosed, getTxFactories, newReadOnlyTransaction, newReadWriteTransaction, newWriteOnlyTransaction

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.opendaylight.controller.md.sal.dom.api.DOMDataBroker

newReadOnlyTransaction, newReadWriteTransaction, newWriteOnlyTransaction

Constructor Detail

ConcurrentDOMDataBroker

public ConcurrentDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores,
                               Executor listenableFutureExecutor)

ConcurrentDOMDataBroker

public ConcurrentDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores,
                               Executor listenableFutureExecutor,
                               org.opendaylight.yangtools.util.DurationStatisticsTracker commitStatsTracker)

Method Detail

getCommitStatsTracker

public org.opendaylight.yangtools.util.DurationStatisticsTracker getCommitStatsTracker()

submit

protected com.google.common.util.concurrent.CheckedFuture<Void,TransactionCommitFailedException> submit(DOMDataWriteTransaction transaction,
                                                                                                        Collection<DOMStoreThreePhaseCommitCohort> cohorts)

Description copied from class: AbstractDOMTransactionFactory

Submits a transaction asynchronously for commit.

Specified by:

submit in class AbstractDOMTransactionFactory<DOMStore>

Parameters:

transaction - the transaction to submit

cohorts - the associated cohorts

Returns:

a resulting Future

toString

public String toString()

Overrides:

toString in class Object

setCloseable

public void setCloseable(AutoCloseable closeable)

close

public void close()

Specified by:

close in interface AutoCloseable

Overrides:

close in class AbstractDOMTransactionFactory<DOMStore>

newTransactionIdentifier

protected Object newTransactionIdentifier()

Description copied from class: AbstractDOMTransactionFactory

Implementations must return unique identifier for each and every call of this method.

Specified by:

newTransactionIdentifier in class AbstractDOMTransactionFactory<DOMStore>

Returns:

new Unique transaction identifier.

registerDataChangeListener

public org.opendaylight.yangtools.concepts.ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(LogicalDatastoreType store,
                                                                                                                  org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path,
                                                                                                                  DOMDataChangeListener listener,
                                                                                                                  AsyncDataBroker.DataChangeScope triggeringScope)

Description copied from interface: AsyncDataBroker

Registers a AsyncDataChangeListener to receive notifications when data changes under a given path in the conceptual data tree.

You are able to register for notifications for any node or subtree which can be reached via the supplied path.

If path type P allows it, you may specify paths up to the leaf nodes then it is possible to listen on leaf nodes.

You are able to register for data change notifications for a subtree even if it does not exist. You will receive notification once that node is created.

If there is any preexisting data in data tree on path for which you are registering, you will receive initial data change event, which will contain all preexisting data, marked as created.

You are also able to specify the scope of the changes you want to be notified.

Supported scopes are:

• AsyncDataBroker.DataChangeScope.BASE - notification events will only be triggered when a node referenced by path is created, removed or replaced.
• AsyncDataBroker.DataChangeScope.ONE - notifications events will only be triggered when a node referenced by path is created, removed or replaced, or any or any of its immediate children are created, updated or removed.
• AsyncDataBroker.DataChangeScope.SUBTREE - notification events will be triggered when a node referenced by the path is created, removed or replaced or any of the children in its subtree are created, removed or replaced.

See AsyncDataBroker.DataChangeScope for examples.

This method returns a ListenerRegistration object. To "unregister" your listener for changes call the "close" method on this returned object.

You MUST call close when you no longer need to receive notifications (such as during shutdown or for example if your bundle is shutting down).

Specified by:

registerDataChangeListener in interface AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>

Parameters:

store - Logical Data Store - Logical Datastore you want to listen for changes in. For example LogicalDatastoreType.OPERATIONAL or LogicalDatastoreType.CONFIGURATION

path - Path (subtree identifier) on which client listener will be invoked.

listener - Instance of listener which should be invoked on

triggeringScope - Scope of change which triggers callback.

Returns:

Listener registration object, which may be used to unregister your listener using ListenerRegistration.close() to stop delivery of change events.

getSupportedExtensions

public Map<Class<? extends DOMDataBrokerExtension>,DOMDataBrokerExtension> getSupportedExtensions()

Description copied from interface: DOMExtensibleService

Return a map of currently-supported extensions, along with accessor services which provide access to the specific functionality bound to this service.

Specified by:

getSupportedExtensions in interface DOMExtensibleService<DOMDataBroker,DOMDataBrokerExtension>

Returns:

A map of supported functionality.

createTransactionChain

public DOMTransactionChain createTransactionChain(TransactionChainListener listener)

Description copied from interface: DOMDataBroker

Create a new transaction chain. The chain will be initialized to read from its backing datastore, with no outstanding transaction. Listener will be registered to handle chain-level events.

Specified by:

createTransactionChain in interface TransactionChainFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>

Specified by:

createTransactionChain in interface DOMDataBroker

Parameters:

listener - Transaction chain event listener

Returns:

A new transaction chain.