From: Robert Varga Date: Wed, 9 Apr 2014 16:23:19 +0000 (+0200) Subject: BUG-694: Disable DataReader registration for BA Broker X-Git-Tag: autorelease-tag-v20140601202136_82eb3f9~248^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=ba1f2b8b1012ca100c84052f082bfa54d8004426 BUG-694: Disable DataReader registration for BA Broker The DataReader's semantic contract with its users, data merge, when working with Binding-Aware DTOs. The existing DataReaders implementations need to be rewritten as datastores, which deal with the same problem in Binding Independent format, such as the BI Data Broker. Change-Id: I91b4516bb04a570acb6bf2b381860e9ae3fbbd43 Signed-off-by: Robert Varga --- 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 48ccbfbc95..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,102 +5,115 @@ * 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.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.controller.sal.binding.impl.util.BindingAwareDataReaderRouter; +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 { - + +public class DataBrokerImpl extends + AbstractDataBroker, DataObject, DataChangeListener> // + implements DataProviderService, AutoCloseable { + private final static class ContainsWildcarded implements Predicate> { - private final InstanceIdentifier key; + private final InstanceIdentifier key; - public ContainsWildcarded(InstanceIdentifier key) { + public ContainsWildcarded(final InstanceIdentifier key) { this.key = key; } @Override - public boolean apply(InstanceIdentifier input) { + public boolean apply(final InstanceIdentifier input) { return key.containsWildcarded(input); } } private final static class IsContainedWildcarded implements Predicate> { - private final InstanceIdentifier key; + private final InstanceIdentifier key; - public IsContainedWildcarded(InstanceIdentifier key) { + public IsContainedWildcarded(final InstanceIdentifier key) { this.key = key; } @Override - public boolean apply(InstanceIdentifier input) { + public boolean apply(final InstanceIdentifier input) { return input.containsWildcarded(key); } } - 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 - public void close() { - + 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 - protected Predicate> createContainsPredicate(final - InstanceIdentifier key) { + public void close() { + + } + + @Override + protected Predicate> createContainsPredicate( + final InstanceIdentifier key) { return new ContainsWildcarded(key); } @Override - protected Predicate> createIsContainedPredicate(final - InstanceIdentifier key) { + protected Predicate> createIsContainedPredicate( + final InstanceIdentifier key) { return new IsContainedWildcarded(key); } @SuppressWarnings({ "unchecked", "rawtypes" }) @Override protected Map, DataObject> deepGetBySubpath( - Map, DataObject> dataSet, - InstanceIdentifier path) { + 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()) { + 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)); + builder.putAll(DataObjectReadingUtil.readData(entry.getValue(), (InstanceIdentifier) entry.getKey(), + path)); } catch (Exception e) { // FIXME : Log exception; } @@ -108,5 +121,58 @@ public class DataBrokerImpl extends AbstractDataBroker, 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; + } + } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/MountPointManagerImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/MountPointManagerImpl.java index 29ba57f30e..b999a6f01c 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/MountPointManagerImpl.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/MountPointManagerImpl.java @@ -118,6 +118,11 @@ public class MountPointManagerImpl implements MountProviderService { super(rpcRegistry, notificationBroker, dataBroker); this.identifier = identifier; } + + // Needed only for BI Connector + public DataBrokerImpl getDataBrokerImpl() { + return (DataBrokerImpl) getDataBroker(); + } @Override public InstanceIdentifier getIdentifier() { diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java index 37c0dfa607..9edea0c2fd 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java @@ -35,7 +35,6 @@ import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandlerRegistration; import org.opendaylight.controller.md.sal.common.api.data.DataModification; -import org.opendaylight.controller.md.sal.common.api.data.DataReader; import org.opendaylight.controller.md.sal.common.api.routing.RouteChange; import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener; import org.opendaylight.controller.md.sal.common.api.routing.RouteChangePublisher; @@ -46,6 +45,8 @@ import org.opendaylight.controller.sal.binding.api.data.DataProviderService; import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider; import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier; import org.opendaylight.controller.sal.binding.api.rpc.RpcRouter; +import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl; +import org.opendaylight.controller.sal.binding.impl.MountPointManagerImpl.BindingMountPointImpl; import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl; import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl.GlobalRpcRegistrationListener; import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl.RouterInstantiationListener; @@ -100,8 +101,6 @@ public class BindingIndependentConnector implements // private final Logger LOG = LoggerFactory.getLogger(BindingIndependentConnector.class); - @SuppressWarnings("deprecation") - private static final InstanceIdentifier ROOT = InstanceIdentifier.builder().toInstance(); private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier ROOT_BI = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier .builder().toInstance(); @@ -140,8 +139,6 @@ public class BindingIndependentConnector implements // }; - private Registration, DataObject>> baDataReaderRegistration; - private boolean rpcForwarding = false; private boolean dataForwarding = false; @@ -306,11 +303,23 @@ public class BindingIndependentConnector implements // dataForwarding = true; return; } - checkState(!dataForwarding, "Connector is already forwarding data."); - baDataReaderRegistration = baDataService.registerDataReader(ROOT, this); - baCommitHandlerRegistration = baDataService.registerCommitHandler(ROOT, bindingToDomCommitHandler); - biCommitHandlerRegistration = biDataService.registerCommitHandler(ROOT_BI, domToBindingCommitHandler); - baDataService.registerCommitHandlerListener(domToBindingCommitHandler); + + final DataProviderService baData; + if (baDataService instanceof BindingMountPointImpl) { + baData = ((BindingMountPointImpl)baDataService).getDataBrokerImpl(); + LOG.debug("Extracted BA Data provider {} from mount point {}", baData, baDataService); + } else { + baData = baDataService; + } + + if (baData instanceof DataBrokerImpl) { + checkState(!dataForwarding, "Connector is already forwarding data."); + ((DataBrokerImpl) baData).setDataReadDelegate(this); + ((DataBrokerImpl) baData).setRootCommitHandler(bindingToDomCommitHandler); + biCommitHandlerRegistration = biDataService.registerCommitHandler(ROOT_BI, domToBindingCommitHandler); + baDataService.registerCommitHandlerListener(domToBindingCommitHandler); + } + dataForwarding = true; }