X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fimpl%2FDataBrokerImpl.java;h=9ede01b6a3e62ba3bdbd685b22309ab799b09ba7;hp=3cc66c30c10e490d1b652f6357d9b1ef308be3d2;hb=b66923141fce710094cb8e61bf794f9f0e678f50;hpb=2c7c9ef5e517de98e0d740f938762cc746dbcde1 diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.java index 3cc66c30c1..9ede01b6a3 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.java @@ -5,123 +5,174 @@ * 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.sal.binding.impl; - +package org.opendaylight.controller.sal.binding.impl; + +import java.util.Map; +import java.util.Map.Entry; import java.util.Set; -import java.util.concurrent.Future; -import java.util.concurrent.atomic.AtomicLong; - -import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataBroker; -import org.opendaylight.controller.sal.binding.api.data.DataChangeListener; -import org.opendaylight.controller.sal.binding.api.data.DataProviderService; -import org.opendaylight.controller.sal.binding.impl.util.BindingAwareDataReaderRouter; -import org.opendaylight.controller.sal.common.DataStoreIdentifier; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.DataRoot; -import org.opendaylight.yangtools.yang.binding.Identifiable; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.common.RpcResult; - - -public class DataBrokerImpl extends AbstractDataBroker, DataObject, DataChangeListener> // - implements DataProviderService, AutoCloseable { - - private final AtomicLong nextTransaction = new AtomicLong(); - private final AtomicLong createdTransactionsCount = new AtomicLong(); - - public AtomicLong getCreatedTransactionsCount() { - return createdTransactionsCount; - } - - public DataBrokerImpl() { - setDataReadRouter(new BindingAwareDataReaderRouter()); - } - - @Override - public DataTransactionImpl beginTransaction() { - String transactionId = "BA-" + nextTransaction.getAndIncrement(); - createdTransactionsCount.getAndIncrement(); - return new DataTransactionImpl(transactionId,this); - } - - @Override - @Deprecated - public T getData(DataStoreIdentifier store, Class rootType) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public T getData(DataStoreIdentifier store, T filter) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public T getCandidateData(DataStoreIdentifier store, Class rootType) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public T getCandidateData(DataStoreIdentifier store, T filter) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public RpcResult editCandidateData(DataStoreIdentifier store, DataRoot changeSet) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public Future> commit(DataStoreIdentifier store) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public DataObject getData(InstanceIdentifier data) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public DataObject getConfigurationData(InstanceIdentifier data) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public void registerChangeListener(InstanceIdentifier path, DataChangeListener changeListener) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - @Deprecated - public void unregisterChangeListener(InstanceIdentifier path, - DataChangeListener changeListener) { - throw new UnsupportedOperationException("Deprecated"); - } - - @Override - public void close() throws Exception { - +import java.util.concurrent.atomic.AtomicLong; + +import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler; +import org.opendaylight.controller.md.sal.common.api.data.DataReader; +import org.opendaylight.controller.md.sal.common.impl.routing.AbstractDataReadRouter; +import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataBroker; +import org.opendaylight.controller.sal.binding.api.data.DataChangeListener; +import org.opendaylight.controller.sal.binding.api.data.DataProviderService; +import org.opendaylight.yangtools.concepts.Registration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.util.DataObjectReadingUtil; + +import com.google.common.base.Predicate; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMap.Builder; +import com.google.common.collect.Maps; + +public class DataBrokerImpl extends + AbstractDataBroker, DataObject, DataChangeListener> // + implements DataProviderService, AutoCloseable { + + private final static class ContainsWildcarded implements Predicate> { + + private final InstanceIdentifier key; + + public ContainsWildcarded(final InstanceIdentifier key) { + this.key = key; + } + + @Override + public boolean apply(final InstanceIdentifier input) { + return key.containsWildcarded(input); + } } - - - @Override - protected boolean isAffectedBy(InstanceIdentifier key, - Set> paths) { - if (paths.contains(key)) { - return true; + + private final static class IsContainedWildcarded implements Predicate> { + + private final InstanceIdentifier key; + + public IsContainedWildcarded(final InstanceIdentifier key) { + this.key = key; + } + + @Override + public boolean apply(final InstanceIdentifier input) { + return input.containsWildcarded(key); } - for (InstanceIdentifier path : paths) { - if (key.containsWildcarded(path)) { - return true; + } + + private final AtomicLong nextTransaction = new AtomicLong(); + private final AtomicLong createdTransactionsCount = new AtomicLong(); + private final DelegatingDataReadRouter router = new DelegatingDataReadRouter(); + private DataCommitHandler, DataObject> rootCommitHandler; + + public DataBrokerImpl() { + setDataReadRouter(router); + } + + public void setDataReadDelegate(final DataReader, DataObject> delegate) { + router.setDelegate(delegate); + } + + public AtomicLong getCreatedTransactionsCount() { + return createdTransactionsCount; + } + + @Override + public DataTransactionImpl beginTransaction() { + String transactionId = "BA-" + nextTransaction.getAndIncrement(); + createdTransactionsCount.getAndIncrement(); + return new DataTransactionImpl(transactionId, this); + } + + @Override + public void close() { + + } + + @Override + protected Predicate> createContainsPredicate( + final InstanceIdentifier key) { + return new ContainsWildcarded(key); + } + + @Override + protected Predicate> createIsContainedPredicate( + final InstanceIdentifier key) { + return new IsContainedWildcarded(key); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + protected Map, DataObject> deepGetBySubpath( + final Map, DataObject> dataSet, + final InstanceIdentifier path) { + Builder, DataObject> builder = ImmutableMap.builder(); + Map, DataObject> potential = Maps.filterKeys(dataSet, + createIsContainedPredicate(path)); + for (Entry, DataObject> entry : potential.entrySet()) { + try { + builder.putAll(DataObjectReadingUtil.readData(entry.getValue(), (InstanceIdentifier) entry.getKey(), + path)); + } catch (Exception e) { + // FIXME : Log exception; } } - return false; - } + return builder.build(); + + } + + public class DelegatingDataReadRouter extends + AbstractDataReadRouter, DataObject> { + + private DataReader, DataObject> delegate; + + @Override + public DataObject readConfigurationData(final InstanceIdentifier path) { + return delegate.readConfigurationData(path); + } + + public void setDelegate(final DataReader, DataObject> delegate) { + this.delegate = delegate; + } + + @Override + public DataObject readOperationalData(final InstanceIdentifier path) { + return delegate.readOperationalData(path); + } + + @Override + protected DataObject merge(final InstanceIdentifier path, final Iterable data) { + throw new UnsupportedOperationException("Not supported"); + } + + @Override + public Registration, DataObject>> registerConfigurationReader( + final InstanceIdentifier path, + final DataReader, DataObject> reader) { + throw new UnsupportedOperationException("Not supported"); + } + + @Override + public Registration, DataObject>> registerOperationalReader( + final InstanceIdentifier path, + final DataReader, DataObject> reader) { + throw new UnsupportedOperationException("Not supported"); + } + } + + @Override + protected ImmutableList, DataObject>> affectedCommitHandlers( + final Set> paths) { + ImmutableList.Builder, DataObject>> handlersBuilder = ImmutableList.builder(); + return handlersBuilder // + .add(rootCommitHandler) // + .addAll(super.affectedCommitHandlers(paths)) // + .build(); + } + + public void setRootCommitHandler(final DataCommitHandler, DataObject> commitHandler) { + rootCommitHandler = commitHandler; + } + }