org.opendaylight.controller.md.sal.dom.broker.impl

Class AbstractDOMDataBroker

java.lang.Object

org.opendaylight.controller.md.sal.dom.broker.impl.AbstractDOMDataBroker

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

Direct Known Subclasses:

SerializedDOMDataBroker

public abstract class AbstractDOMDataBroker
extends Object
implements DOMDataBroker, AutoCloseable

Nested Class Summary

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

AsyncDataBroker.DataChangeScope

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores)

Method Summary

Modifier and Type	Method and Description
protected void	checkNotClosed() Checks if instance is not closed.
void	close()
DOMTransactionChain	createTransactionChain(TransactionChainListener listener) Create a new transaction chain.
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 Map<LogicalDatastoreType,T>	getTxFactories() Convenience accessor of backing factories intended to be used only by finalization of this class.
DOMDataReadOnlyTransaction	newReadOnlyTransaction() Creates a new composite read-only transaction
DOMDataReadWriteTransaction	newReadWriteTransaction() Creates a new composite write-only transaction
protected Object	newTransactionIdentifier() Implementations must return unique identifier for each and every call of this method.
DOMDataWriteTransaction	newWriteOnlyTransaction() Creates a new composite write-only transaction
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 abstract com.google.common.util.concurrent.CheckedFuture<Void,TransactionCommitFailedException>	submit(DOMDataWriteTransaction transaction, Collection<DOMStoreThreePhaseCommitCohort> cohorts) User-supplied implementation of AsyncWriteTransaction.submit() for transaction.

Methods inherited from class java.lang.Object

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

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

newReadOnlyTransaction, newReadWriteTransaction, newWriteOnlyTransaction

Constructor Detail

AbstractDOMDataBroker

protected AbstractDOMDataBroker(Map<LogicalDatastoreType,DOMStore> datastores)

Method Detail

setCloseable

public void setCloseable(AutoCloseable closeable)

close

public void close()

Specified by:

close in interface AutoCloseable

newTransactionIdentifier

protected Object newTransactionIdentifier()

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

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

@Nonnull
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.

submit

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

User-supplied implementation of AsyncWriteTransaction.submit() for transaction.

Callback invoked when AsyncWriteTransaction.submit() is invoked on transaction created by this factory.

Parameters:

transaction - Transaction on which AsyncWriteTransaction.commit() was invoked.

cohorts - Iteratable of cohorts for subtransactions associated with the transaction being committed.

Returns:

a CheckedFuture. if commit coordination on cohorts finished successfully, nothing is returned from the Future, On failure, the Future fails with a TransactionCommitFailedException.

newReadOnlyTransaction

public final DOMDataReadOnlyTransaction newReadOnlyTransaction()

Creates a new composite read-only transaction

Creates a new composite read-only transaction backed by one transaction per factory in getTxFactories().

Subtransaction for reading is selected by supplied LogicalDatastoreType as parameter for DOMDataReadTransaction.read(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier).

Id of returned transaction is retrieved via newTransactionIdentifier().

Returns:

New composite read-only transaction.

newWriteOnlyTransaction

public final DOMDataWriteTransaction newWriteOnlyTransaction()

Creates a new composite write-only transaction

Creates a new composite write-only transaction backed by one write-only transaction per factory in getTxFactories().

Implementation of composite Write-only transaction is following:

• DOMDataWriteTransaction.put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreWriteTransaction.write(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) is invoked on selected subtransaction.
• DOMDataWriteTransaction.merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreWriteTransaction.merge(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) is invoked on selected subtransaction.
• AsyncWriteTransaction.delete(LogicalDatastoreType, Path) DOMStoreWriteTransaction.delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier) is invoked on selected subtransaction.
• AsyncWriteTransaction.commit() - results in invoking DOMStoreWriteTransaction.ready(), gathering all resulting cohorts and then invoking finalized implementation callback submit(DOMDataWriteTransaction, Collection) with transaction which was commited and gathered results.

Id of returned transaction is generated via newTransactionIdentifier().

Returns:

New composite write-only transaction associated with this factory.

newReadWriteTransaction

public final DOMDataReadWriteTransaction newReadWriteTransaction()

Creates a new composite write-only transaction

Creates a new composite write-only transaction backed by one write-only transaction per factory in getTxFactories().

Implementation of composite Write-only transaction is following:

• DOMDataReadTransaction.read(LogicalDatastoreType, YangInstanceIdentifier) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreReadTransaction.read(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier) is invoked on selected subtransaction.
• DOMDataWriteTransaction.put(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreWriteTransaction.write(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) is invoked on selected subtransaction.
• DOMDataWriteTransaction.merge(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreWriteTransaction.merge(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode) is invoked on selected subtransaction.
• DOMDataWriteTransaction.delete(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier) - backing subtransaction is selected by LogicalDatastoreType, DOMStoreWriteTransaction.delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier) is invoked on selected subtransaction.
• AsyncWriteTransaction.commit() - results in invoking DOMStoreWriteTransaction.ready(), gathering all resulting cohorts and then invoking finalized implementation callback submit(DOMDataWriteTransaction, Collection) with transaction which was committed and gathered results.

Id of returned transaction is generated via newTransactionIdentifier().

Returns:

New composite read-write transaction associated with this factory.

getTxFactories

protected final Map<LogicalDatastoreType,T> getTxFactories()

Convenience accessor of backing factories intended to be used only by finalization of this class. Note: Finalization of this class may want to access other functionality of supplied Transaction factories.

Returns:

Map of backing transaction factories.

checkNotClosed

protected final void checkNotClosed()

Checks if instance is not closed.

Throws:

IllegalStateException - If instance of this class was closed.