From be2b35105f8e10ada7d73f4523a5a931c57323b3 Mon Sep 17 00:00:00 2001 From: Ed Warnicke Date: Fri, 15 Aug 2014 14:49:27 +0000 Subject: [PATCH] Revert "BUG-1425: Integrated new Binding to Normalized Node codec for write path" This reverts commit eb2bd48a9148a4fbeae292ffd03e30083c2ff024. Change-Id: Ic8183f6620c51d8a4a87a38af1e9a554e7f9016a Signed-off-by: Ed Warnicke --- .../md-sal/sal-binding-broker/pom.xml | 5 - .../BindingAsyncDataBrokerImplModule.java | 5 +- .../binding/impl/DataBrokerImplModule.java | 79 +++ .../impl/DataBrokerImplModuleFactory.java | 17 + ...rwardedCompatibleDataBrokerImplModule.java | 10 +- .../binding/impl/RuntimeMappingModule.java | 80 ++- .../impl/AbstractForwardedDataBroker.java | 58 ++- .../impl/BindingToNormalizedNodeCodec.java | 493 ++++++++++++++++-- ...orwardedBackwardsCompatibleDataBroker.java | 17 +- .../impl/ForwardedBindingDataBroker.java | 5 +- .../binding/codegen/impl/SingletonHolder.java | 13 +- .../sal/binding/impl/RootDataBrokerImpl.java | 50 ++ .../forward/DomForwardedDataBrokerImpl.java | 56 ++ .../opendaylight-binding-broker-impl.yang | 41 +- .../impl/test/BindingNormalizedCodecTest.java | 10 +- .../test/DataBrokerTestCustomizer.java | 28 +- .../compat/MultipleAugmentationPutsTest.java | 15 +- .../binding/test/util/BindingTestContext.java | 36 +- .../test/sal/binding/it/TestHelper.java | 1 - .../test/sal/binding/it/DataServiceTest.java | 36 +- .../src/test/resources/controller.xml | 186 ++++--- 21 files changed, 955 insertions(+), 286 deletions(-) create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModule.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModuleFactory.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RootDataBrokerImpl.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/forward/DomForwardedDataBrokerImpl.java diff --git a/opendaylight/md-sal/sal-binding-broker/pom.xml b/opendaylight/md-sal/sal-binding-broker/pom.xml index 539f9d45c8..74cceb1cbd 100644 --- a/opendaylight/md-sal/sal-binding-broker/pom.xml +++ b/opendaylight/md-sal/sal-binding-broker/pom.xml @@ -67,11 +67,6 @@ org.opendaylight.yangtools binding-generator-impl - - org.opendaylight.yangtools - binding-data-codec - 0.6.2-SNAPSHOT - org.opendaylight.yangtools yang-data-impl diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingAsyncDataBrokerImplModule.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingAsyncDataBrokerImplModule.java index 93d99c832f..018e26878c 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingAsyncDataBrokerImplModule.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingAsyncDataBrokerImplModule.java @@ -2,13 +2,14 @@ package org.opendaylight.controller.config.yang.md.sal.binding.impl; import java.util.Collection; import java.util.Collections; -import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; + import org.opendaylight.controller.md.sal.binding.impl.ForwardedBindingDataBroker; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.sal.core.api.Broker; import org.opendaylight.controller.sal.core.api.Broker.ProviderSession; import org.opendaylight.controller.sal.core.api.Provider; import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; public class BindingAsyncDataBrokerImplModule extends org.opendaylight.controller.config.yang.md.sal.binding.impl.AbstractBindingAsyncDataBrokerImplModule implements @@ -35,7 +36,7 @@ public class BindingAsyncDataBrokerImplModule extends @Override public java.lang.AutoCloseable createInstance() { Broker domBroker = getDomAsyncBrokerDependency(); - BindingToNormalizedNodeCodec mappingService = getBindingMappingServiceDependency(); + BindingIndependentMappingService mappingService = getBindingMappingServiceDependency(); // FIXME: Switch this to DOM Broker registration which would not require // BundleContext when API are updated. diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModule.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModule.java new file mode 100644 index 0000000000..4a4e800078 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModule.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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.config.yang.md.sal.binding.impl; + +import java.util.concurrent.ExecutorService; + +import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder; +import org.opendaylight.controller.sal.binding.impl.RootDataBrokerImpl; +import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer; +import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector; +import org.opendaylight.controller.sal.binding.impl.forward.DomForwardedDataBrokerImpl; +import org.opendaylight.controller.sal.core.api.Broker.ProviderSession; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; + +/** +* +*/ +public final class DataBrokerImplModule extends + org.opendaylight.controller.config.yang.md.sal.binding.impl.AbstractDataBrokerImplModule { + + public DataBrokerImplModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, + final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + super(identifier, dependencyResolver); + } + + public DataBrokerImplModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, + final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, + final DataBrokerImplModule oldModule, final java.lang.AutoCloseable oldInstance) { + super(identifier, dependencyResolver, oldModule, oldInstance); + } + + @Override + public void validate() { + super.validate(); + } + + @Override + public java.lang.AutoCloseable createInstance() { + RootDataBrokerImpl dataBindingBroker; + + + ExecutorService listeningExecutor = SingletonHolder.getDefaultCommitExecutor(); + BindingIndependentMappingService potentialMapping = getMappingServiceDependency(); + if (getDomBrokerDependency() != null && potentialMapping != null) { + + dataBindingBroker = createDomConnectedBroker(listeningExecutor,potentialMapping); + } else { + dataBindingBroker = createStandAloneBroker(listeningExecutor); + } + dataBindingBroker.registerRuntimeBean(getRootRuntimeBeanRegistratorWrapper()); + dataBindingBroker.setNotificationExecutor(SingletonHolder.getDefaultChangeEventExecutor()); + return dataBindingBroker; + } + + + private RootDataBrokerImpl createStandAloneBroker(final ExecutorService listeningExecutor) { + RootDataBrokerImpl broker = new RootDataBrokerImpl(); + broker.setExecutor(listeningExecutor); + return broker; + } + + private RootDataBrokerImpl createDomConnectedBroker(final ExecutorService listeningExecutor, final BindingIndependentMappingService mappingService) { + DomForwardedDataBrokerImpl forwardedBroker = new DomForwardedDataBrokerImpl(); + forwardedBroker.setExecutor(listeningExecutor); + BindingIndependentConnector connector = BindingDomConnectorDeployer.createConnector(mappingService); + getDomBrokerDependency().registerProvider(forwardedBroker, null); + ProviderSession domContext = forwardedBroker.getDomProviderContext(); + forwardedBroker.setConnector(connector); + forwardedBroker.setDomProviderContext(domContext); + forwardedBroker.startForwarding(); + return forwardedBroker; + } + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModuleFactory.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModuleFactory.java new file mode 100644 index 0000000000..d3fc5ac215 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/DataBrokerImplModuleFactory.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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.config.yang.md.sal.binding.impl; + + +/** +* +*/ +public class DataBrokerImplModuleFactory extends + org.opendaylight.controller.config.yang.md.sal.binding.impl.AbstractDataBrokerImplModuleFactory { + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/ForwardedCompatibleDataBrokerImplModule.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/ForwardedCompatibleDataBrokerImplModule.java index 2bc673adff..0ea30f7e66 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/ForwardedCompatibleDataBrokerImplModule.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/ForwardedCompatibleDataBrokerImplModule.java @@ -7,10 +7,9 @@ */ package org.opendaylight.controller.config.yang.md.sal.binding.impl; -import com.google.common.util.concurrent.ListeningExecutorService; import java.util.Collection; import java.util.Collections; -import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; + import org.opendaylight.controller.md.sal.binding.impl.ForwardedBackwardsCompatibleDataBroker; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder; @@ -19,6 +18,9 @@ import org.opendaylight.controller.sal.core.api.Broker; import org.opendaylight.controller.sal.core.api.Broker.ProviderSession; import org.opendaylight.controller.sal.core.api.Provider; import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; + +import com.google.common.util.concurrent.ListeningExecutorService; /** * @@ -49,7 +51,7 @@ public final class ForwardedCompatibleDataBrokerImplModule extends @Override public java.lang.AutoCloseable createInstance() { ListeningExecutorService listeningExecutor = SingletonHolder.getDefaultCommitExecutor(); - BindingToNormalizedNodeCodec mappingService = getBindingMappingServiceDependency(); + BindingIndependentMappingService mappingService = getBindingMappingServiceDependency(); Broker domBroker = getDomAsyncBrokerDependency(); ProviderSession session = domBroker.registerProvider(this, null); @@ -58,7 +60,7 @@ public final class ForwardedCompatibleDataBrokerImplModule extends ForwardedBackwardsCompatibleDataBroker dataBroker = new ForwardedBackwardsCompatibleDataBroker(domDataBroker, mappingService, schemaService,listeningExecutor); - dataBroker.setConnector(BindingDomConnectorDeployer.createConnector(mappingService.getLegacy())); + dataBroker.setConnector(BindingDomConnectorDeployer.createConnector(getBindingMappingServiceDependency())); dataBroker.setDomProviderContext(session); return dataBroker; } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/RuntimeMappingModule.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/RuntimeMappingModule.java index a15b1d746c..b0c2d742e2 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/RuntimeMappingModule.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/RuntimeMappingModule.java @@ -7,18 +7,12 @@ */ package org.opendaylight.controller.config.yang.md.sal.binding.impl; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; import java.util.Hashtable; import java.util.Map.Entry; import java.util.Set; -import javassist.ClassPool; -import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; + import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator; -import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; import org.opendaylight.yangtools.concepts.Delegator; -import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl; import org.opendaylight.yangtools.yang.binding.DataContainer; import org.opendaylight.yangtools.yang.binding.DataObject; @@ -35,6 +29,9 @@ import org.osgi.framework.ServiceReference; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; + /** * */ @@ -45,14 +42,14 @@ public final class RuntimeMappingModule extends private BundleContext bundleContext; - public RuntimeMappingModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, - final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + public RuntimeMappingModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, + org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { super(identifier, dependencyResolver); } - public RuntimeMappingModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, - final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, - final RuntimeMappingModule oldModule, final java.lang.AutoCloseable oldInstance) { + public RuntimeMappingModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, + org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, + RuntimeMappingModule oldModule, java.lang.AutoCloseable oldInstance) { super(identifier, dependencyResolver, oldModule, oldInstance); } @@ -64,48 +61,41 @@ public final class RuntimeMappingModule extends } @Override - public boolean canReuseInstance(final AbstractRuntimeMappingModule oldModule) { + public boolean canReuseInstance(AbstractRuntimeMappingModule oldModule) { return true; } @Override public java.lang.AutoCloseable createInstance() { - final GeneratedClassLoadingStrategy classLoading = getGlobalClassLoadingStrategy(); - final BindingIndependentMappingService legacyMapping = getGlobalLegacyMappingService(classLoading); - BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(new StreamWriterGenerator(SingletonHolder.JAVASSIST)); - BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec(classLoading, legacyMapping, codecRegistry); - bundleContext.registerService(SchemaContextListener.class, instance, new Hashtable()); - return instance; - } - private BindingIndependentMappingService getGlobalLegacyMappingService(final GeneratedClassLoadingStrategy classLoading) { - BindingIndependentMappingService potential = tryToReuseGlobalMappingServiceInstance(); - if(potential == null) { - potential = new RuntimeGeneratedMappingServiceImpl(ClassPool.getDefault(),classLoading); - bundleContext.registerService(SchemaContextListener.class, (SchemaContextListener) potential, new Hashtable()); + RuntimeGeneratedMappingServiceProxy potential = tryToReuseGlobalInstance(); + if(potential != null) { + return potential; } - return potential; - } - private GeneratedClassLoadingStrategy getGlobalClassLoadingStrategy() { - ServiceReference ref = bundleContext.getServiceReference(GeneratedClassLoadingStrategy.class); - return bundleContext.getService(ref); + final RuntimeGeneratedMappingServiceImpl service = new RuntimeGeneratedMappingServiceImpl(SingletonHolder.CLASS_POOL); + bundleContext.registerService(SchemaContextListener.class, service, new Hashtable()); + return service; } - private BindingIndependentMappingService tryToReuseGlobalMappingServiceInstance() { + private RuntimeGeneratedMappingServiceProxy tryToReuseGlobalInstance() { ServiceReference serviceRef = getBundleContext().getServiceReference(BindingIndependentMappingService.class); if(serviceRef == null) { return null; } - return bundleContext.getService(serviceRef); + BindingIndependentMappingService delegate = bundleContext.getService(serviceRef); + if (delegate == null) { + return null; + } + return new RuntimeGeneratedMappingServiceProxy(getBundleContext(),serviceRef,delegate); } private BundleContext getBundleContext() { return bundleContext; } - public void setBundleContext(final BundleContext bundleContext) { + public void setBundleContext(BundleContext bundleContext) { this.bundleContext = bundleContext; } @@ -118,9 +108,9 @@ public final class RuntimeMappingModule extends private ServiceReference reference; private BundleContext bundleContext; - public RuntimeGeneratedMappingServiceProxy(final BundleContext bundleContext, - final ServiceReference serviceRef, - final BindingIndependentMappingService delegate) { + public RuntimeGeneratedMappingServiceProxy(BundleContext bundleContext, + ServiceReference serviceRef, + BindingIndependentMappingService delegate) { this.bundleContext = Preconditions.checkNotNull(bundleContext); this.reference = Preconditions.checkNotNull(serviceRef); this.delegate = Preconditions.checkNotNull(delegate); @@ -132,47 +122,47 @@ public final class RuntimeMappingModule extends } @Override - public CompositeNode toDataDom(final DataObject data) { + public CompositeNode toDataDom(DataObject data) { return delegate.toDataDom(data); } @Override public Entry toDataDom( - final Entry, DataObject> entry) { + Entry, DataObject> entry) { return delegate.toDataDom(entry); } @Override public YangInstanceIdentifier toDataDom( - final org.opendaylight.yangtools.yang.binding.InstanceIdentifier path) { + org.opendaylight.yangtools.yang.binding.InstanceIdentifier path) { return delegate.toDataDom(path); } @Override public DataObject dataObjectFromDataDom( - final org.opendaylight.yangtools.yang.binding.InstanceIdentifier path, - final CompositeNode result) throws DeserializationException { + org.opendaylight.yangtools.yang.binding.InstanceIdentifier path, + CompositeNode result) throws DeserializationException { return delegate.dataObjectFromDataDom(path, result); } @Override - public org.opendaylight.yangtools.yang.binding.InstanceIdentifier fromDataDom(final YangInstanceIdentifier entry) + public org.opendaylight.yangtools.yang.binding.InstanceIdentifier fromDataDom(YangInstanceIdentifier entry) throws DeserializationException { return delegate.fromDataDom(entry); } @Override - public Set getRpcQNamesFor(final Class service) { + public Set getRpcQNamesFor(Class service) { return delegate.getRpcQNamesFor(service); } @Override - public Optional> getRpcServiceClassFor(final String namespace, final String revision) { + public Optional> getRpcServiceClassFor(String namespace, String revision) { return delegate.getRpcServiceClassFor(namespace,revision); } @Override - public DataContainer dataObjectFromDataDom(final Class inputClass, final CompositeNode domInput) { + public DataContainer dataObjectFromDataDom(Class inputClass, CompositeNode domInput) { return delegate.dataObjectFromDataDom(inputClass, domInput); } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedDataBroker.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedDataBroker.java index f843b23f9b..e632e6336a 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedDataBroker.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedDataBroker.java @@ -9,6 +9,7 @@ package org.opendaylight.controller.md.sal.binding.impl; import com.google.common.base.Objects; import com.google.common.base.Optional; + import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; @@ -18,6 +19,7 @@ import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; + import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; @@ -35,28 +37,33 @@ import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public abstract class AbstractForwardedDataBroker implements Delegator, DomForwardedBroker, - SchemaContextListener, AutoCloseable { +public abstract class AbstractForwardedDataBroker implements Delegator, DomForwardedBroker, SchemaContextListener, AutoCloseable { private static final Logger LOG = LoggerFactory.getLogger(AbstractForwardedDataBroker.class); // The Broker to whom we do all forwarding private final DOMDataBroker domDataBroker; + // Mapper to convert from Binding Independent objects to Binding Aware + // objects + private final BindingIndependentMappingService mappingService; + private final BindingToNormalizedNodeCodec codec; private BindingIndependentConnector connector; private ProviderSession context; private final ListenerRegistration schemaListenerRegistration; - protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec, - final SchemaService schemaService) { + protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, + final BindingIndependentMappingService mappingService,final SchemaService schemaService) { this.domDataBroker = domDataBroker; - this.codec = codec; + this.mappingService = mappingService; + this.codec = new BindingToNormalizedNodeCodec(mappingService); this.schemaListenerRegistration = schemaService.registerSchemaContextListener(this); } @@ -64,6 +71,10 @@ public abstract class AbstractForwardedDataBroker implements Delegator registerDataChangeListener(final LogicalDatastoreType store, - final InstanceIdentifier path, final DataChangeListener listener, final DataChangeScope triggeringScope) { + final InstanceIdentifier path, final DataChangeListener listener, + final DataChangeScope triggeringScope) { DOMDataChangeListener domDataChangeListener = new TranslatingDataChangeInvoker(store, path, listener, triggeringScope); YangInstanceIdentifier domPath = codec.toNormalized(path); @@ -84,16 +96,23 @@ public abstract class AbstractForwardedDataBroker implements Delegator, DataObject> toBinding(final InstanceIdentifier path, + protected Map, DataObject> toBinding( + InstanceIdentifier path, final Map> normalized) { Map, DataObject> newMap = new HashMap<>(); for (Map.Entry> entry : sortedEntries(normalized)) { try { - Optional, DataObject>> potential = getCodec().toBinding(entry); + Optional, DataObject>> potential = getCodec().toBinding( + entry); if (potential.isPresent()) { Entry, DataObject> binding = potential.get(); newMap.put(binding.getKey(), binding.getValue()); + } else if (entry.getKey().getLastPathArgument() instanceof YangInstanceIdentifier.AugmentationIdentifier) { + DataObject bindingDataObject = getCodec().toBinding(path, entry.getValue()); + if (bindingDataObject != null) { + newMap.put(path, bindingDataObject); + } } } catch (DeserializationException e) { LOG.warn("Failed to transform {}, omitting it", entry, e); @@ -104,7 +123,8 @@ public abstract class AbstractForwardedDataBroker implements Delegator> MAP_ENTRY_COMPARATOR = new Comparator>() { @Override - public int compare(final Entry left, final Entry right) { + public int compare(final Entry left, + final Entry right) { final Iterator li = left.getKey().getPathArguments().iterator(); final Iterator ri = right.getKey().getPathArguments().iterator(); @@ -124,7 +144,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator Iterable> sortedEntries(final Map map) { + private static Iterable> sortedEntries(final Map map) { if (!map.isEmpty()) { ArrayList> entries = new ArrayList<>(map.entrySet()); Collections.sort(entries, MAP_ENTRY_COMPARATOR); @@ -134,7 +154,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator> toBinding(final InstanceIdentifier path, + protected Set> toBinding(InstanceIdentifier path, final Set normalized) { Set> hashSet = new HashSet<>(); for (YangInstanceIdentifier normalizedPath : normalized) { @@ -157,7 +177,12 @@ public abstract class AbstractForwardedDataBroker implements Delegator> of(data)); + + try { + return Optional.fromNullable(getCodec().toBinding(path, data)); + } catch (DeserializationException e) { + return Optional.absent(); + } } private class TranslatingDataChangeInvoker implements DOMDataChangeListener { @@ -175,7 +200,8 @@ public abstract class AbstractForwardedDataBroker implements Delegator> change) { + public void onDataChanged( + final AsyncDataChangeEvent> change) { bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change, path)); } } @@ -235,7 +261,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator binding) { - return codecRegistry.toYangInstanceIdentifier(binding); + + // Used instance-identifier codec do not support serialization of last + // path + // argument if it is Augmentation (behaviour expected by old datastore) + // in this case, we explicitly check if last argument is augmentation + // to process it separately + if (isAugmentationIdentifier(binding)) { + return toNormalizedAugmented(binding); + } + return toNormalizedImpl(binding); } - @SuppressWarnings({ "unchecked", "rawtypes" }) public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return codecRegistry.toNormalizedNode((InstanceIdentifier) bindingPath, bindingObject); + return toNormalizedNode(toBindingEntry(bindingPath, bindingObject)); } public Entry> toNormalizedNode( final Entry, DataObject> binding) { - return toNormalizedNode(binding.getKey(),binding.getValue()); + Entry legacyEntry = bindingToLegacy + .toDataDom(binding); + Entry> normalizedEntry = legacyToNormalized + .toNormalized(legacyEntry); + LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding, + legacyEntry, normalizedEntry); + if (isAugmentation(binding.getKey().getTargetType())) { + + for (DataContainerChild child : ((DataContainerNode) normalizedEntry + .getValue()).getValue()) { + if (child instanceof AugmentationNode) { + ImmutableList childArgs = ImmutableList. builder() + .addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build(); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier + .create(childArgs); + return toDOMEntry(childPath, child); + } + } + + } + return normalizedEntry; + } /** @@ -75,13 +125,109 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC public Optional> toBinding( final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) throws DeserializationException { + + PathArgument lastArgument = Iterables.getLast(normalized.getPathArguments()); + // Used instance-identifier codec do not support serialization of last + // path + // argument if it is AugmentationIdentifier (behaviour expected by old + // datastore) + // in this case, we explicitly check if last argument is augmentation + // to process it separately + if (lastArgument instanceof AugmentationIdentifier) { + return toBindingAugmented(normalized); + } + return toBindingImpl(normalized); + } + + private Optional> toBindingAugmented( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { + Optional> potential = toBindingImpl(normalized); + // Shorthand check, if codec already supports deserialization + // of AugmentationIdentifier we will return + if (potential.isPresent() && isAugmentationIdentifier(potential.get())) { + return potential; + } + + int normalizedCount = getAugmentationCount(normalized); + AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPathArguments()); + + // Here we employ small trick - Binding-aware Codec injects an pointer + // to augmentation class + // if child is referenced - so we will reference child and then shorten + // path. + LOG.trace("Looking for candidates to match {}", normalized); + for (QName child : lastArgument.getPossibleChildNames()) { + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier childPath = normalized.node(child); + try { + if (isNotRepresentable(childPath)) { + LOG.trace("Path {} is not BI-representable, skipping it", childPath); + continue; + } + } catch (DataNormalizationException e) { + LOG.warn("Failed to denormalize path {}, skipping it", childPath, e); + continue; + } + + Optional> baId = toBindingImpl(childPath); + if (!baId.isPresent()) { + LOG.debug("No binding-aware identifier found for path {}, skipping it", childPath); + continue; + } + + InstanceIdentifier potentialPath = shortenToLastAugment(baId.get()); + int potentialAugmentCount = getAugmentationCount(potentialPath); + if (potentialAugmentCount == normalizedCount) { + LOG.trace("Found matching path {}", potentialPath); + return Optional.> of(potentialPath); + } + + LOG.trace("Skipping mis-matched potential path {}", potentialPath); + } + + LOG.trace("Failed to find augmentation matching {}", normalized); + return Optional.absent(); + } + + private Optional> toBindingImpl( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath; + try { - return Optional.>of(codecRegistry.fromYangInstanceIdentifier(normalized)); - } catch (IllegalArgumentException e) { - return Optional.absent(); + if (isNotRepresentable(normalized)) { + return Optional.absent(); + } + legacyPath = legacyToNormalized.toLegacy(normalized); + } catch (DataNormalizationException e) { + throw new IllegalStateException("Could not denormalize path.", e); + } + LOG.trace("InstanceIdentifier Path Deserialization: Legacy representation {}, Normalized representation: {}", + legacyPath, normalized); + return Optional.> of(bindingToLegacy.fromDataDom(legacyPath)); + } + + private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation op = findNormalizationOperation(normalized); + if (op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) { + return true; + } + if (op.isLeaf()) { + return true; } + return false; } + private DataNormalizationOperation findNormalizationOperation( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation current = legacyToNormalized.getRootOperation(); + for (PathArgument arg : normalized.getPathArguments()) { + current = current.getChild(arg); + } + return current; + } private static final Entry, DataObject> toBindingEntry( final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, @@ -90,19 +236,45 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC key, value); } + private static final Entry> toDOMEntry( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier key, final NormalizedNode value) { + return new SimpleEntry>(key, + value); + } + + public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) + throws DeserializationException { + CompositeNode legacy = null; + if (isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { + QName augIdentifier = BindingReflections.findQName(path.getTargetType()); + ContainerNode virtualNode = Builders.containerBuilder() // + .withNodeIdentifier(new NodeIdentifier(augIdentifier)) // + .withChild((DataContainerChild) normalizedNode) // + .build(); + legacy = (CompositeNode) DataNormalizer.toLegacy(virtualNode); + } else { + legacy = (CompositeNode) DataNormalizer.toLegacy(normalizedNode); + } + + return bindingToLegacy.dataObjectFromDataDom(path, legacy); + } + public DataNormalizer getDataNormalizer() { return legacyToNormalized; } - @SuppressWarnings("unchecked") public Optional, DataObject>> toBinding( final Entry> normalized) throws DeserializationException { - try { - @SuppressWarnings("rawtypes") - Entry binding = codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()); - return Optional., DataObject>>fromNullable(binding); - } catch (IllegalArgumentException e) { + Optional> potentialPath = toBinding(normalized.getKey()); + if (potentialPath.isPresent()) { + InstanceIdentifier bindingPath = potentialPath.get(); + DataObject bindingData = toBinding(bindingPath, normalized.getValue()); + if (bindingData == null) { + LOG.warn("Failed to deserialize {} to Binding format. Binding path is: {}", normalized, bindingPath); + } + return Optional.of(toBindingEntry(bindingPath, bindingData)); + } else { return Optional.absent(); } } @@ -110,11 +282,269 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC @Override public void onGlobalContextUpdated(final SchemaContext arg0) { legacyToNormalized = new DataNormalizer(arg0); - codecRegistry.onBindingRuntimeContextUpdated(BindingRuntimeContext.create(classLoadingStrategy, arg0)); } + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedAugmented( + final InstanceIdentifier augPath) { + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed = toNormalizedImpl(augPath); + // If used instance identifier codec added supports for deserialization + // of last AugmentationIdentifier we will just reuse it + if (isAugmentationIdentifier(processed)) { + return processed; + } + Optional additionalSerialized; + additionalSerialized = toNormalizedAugmentedUsingChildContainers(augPath, processed); + + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + additionalSerialized = toNormalizedAugmentedUsingChildLeafs(augPath, processed); + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + throw new IllegalStateException("Unabled to construct augmentation identfier for " + augPath); + } + + /** + * Tries to find correct augmentation identifier using children leafs + * + * This method uses normalized Instance Identifier of parent node to fetch + * schema and {@link BindingReflections#getModuleInfo(Class)} to learn about + * augmentation namespace, specificly, in which module it was defined. + * + * Then it uses it to filter all available augmentations for parent by + * module. After that it walks augmentations in particular module and + * pick-up first which at least one leaf name matches supplied augmentation. + * We could do this safely since YANG explicitly states that no any existing + * augmentations must differ in leaf fully qualified names. + * + * + * @param augPath + * Binding Aware Path which ends with augment + * @param parentPath + * Processed path + * @return + */ + private Optional toNormalizedAugmentedUsingChildLeafs( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + try { + DataNormalizationOperation parentOp = legacyToNormalized.getOperation(parentPath); + if(!parentOp.getDataSchemaNode().isPresent()) { + return Optional.absent(); + } + DataSchemaNode parentSchema = parentOp.getDataSchemaNode().get(); + if (parentSchema instanceof AugmentationTarget) { + Set augmentations = ((AugmentationTarget) parentSchema).getAvailableAugmentations(); + LOG.info("Augmentations for {}, {}", augPath, augmentations); + Optional schema = findAugmentation(augPath.getTargetType(), augmentations); + if (schema.isPresent()) { + AugmentationIdentifier augmentationIdentifier = DataNormalizationOperation + .augmentationIdentifierFrom(schema.get()); + return Optional.of(parentPath.node(augmentationIdentifier)); + } + } + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(e); + } + return Optional.absent(); + } + + /** + * Creates instance identifier for augmentation child, tries to serialize it + * Instance Identifier is then shortened to last augmentation. + * + * This is for situations, where underlying codec is implementing hydrogen + * style DOM APIs (which did not supported {@link AugmentationIdentifier}.) + * + * @param augPath + * @param parentPath + * Path to parent node + * @return + */ + @SuppressWarnings("rawtypes") + private Optional toNormalizedAugmentedUsingChildContainers( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + for (Class augChild : BindingReflections.getChildrenClasses(augPath.getTargetType())) { + @SuppressWarnings("unchecked") + InstanceIdentifier childPath = augPath.child(augChild); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = toNormalizedImpl(childPath); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potentialDiscovered = shortenToLastAugmentation( + normalized, parentPath); + if (potentialDiscovered != null) { + return Optional.of(potentialDiscovered); + } + } + return Optional.absent(); + } + + private Optional findAugmentation(final Class targetType, + final Set augmentations) { + YangModuleInfo moduleInfo; + try { + moduleInfo = BindingReflections.getModuleInfo(targetType); + } catch (Exception e) { + throw new IllegalStateException(e); + } + Iterable filtered = filteredByModuleInfo(augmentations, + BindingReflections.getModuleQName(moduleInfo).getModule()); + filtered.toString(); + Set targetTypeGetters = getYangModeledGetters(targetType); + for (AugmentationSchema schema : filtered) { + for (DataSchemaNode child : schema.getChildNodes()) { + String getterName = "get" + BindingMapping.getClassName(child.getQName()); + if (targetTypeGetters.contains(getterName)) { + return Optional.of(schema); + } + } + } + return Optional.absent(); + } + + private static Iterable filteredByModuleInfo(final Iterable augmentations, + final QNameModule module) { + return Iterables.filter(augmentations, new Predicate() { + @Override + public boolean apply(final AugmentationSchema schema) { + final Collection childNodes = schema.getChildNodes(); + return !childNodes.isEmpty() && module.equals(Iterables.get(childNodes, 0).getQName().getModule()); + } + }); + } + + public static final Set getYangModeledGetters(final Class targetType) { + HashSet ret = new HashSet(); + for (Method method : targetType.getMethods()) { + if (isYangModeledGetter(method)) { + ret.add(method.getName()); + } + } + return ret; + } + + /** + * + * Returns true if supplied method represent getter for YANG modeled value + * + * @param method + * Method to be tested + * @return true if method represent getter for YANG Modeled value. + */ + private static final boolean isYangModeledGetter(final Method method) { + return !method.getName().equals("getClass") && !method.getName().equals("getImplementedInterface") + && method.getName().startsWith("get") && method.getParameterTypes().length == 0; + } + + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier shortenToLastAugmentation( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + int parentSize = Iterables.size(parentPath.getPathArguments()); + int position = 0; + int foundPosition = -1; + for (PathArgument arg : normalized.getPathArguments()) { + position++; + if (arg instanceof AugmentationIdentifier) { + foundPosition = position; + } + } + if (foundPosition > 0 && foundPosition > parentSize) { + Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); + return org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(shortened); + } + return null; + } + + private InstanceIdentifier shortenToLastAugment( + final InstanceIdentifier binding) { + int position = 0; + int foundPosition = -1; + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { + position++; + if (isAugmentation(arg.getType())) { + foundPosition = position; + } + } + return InstanceIdentifier.create(Iterables.limit(binding.getPathArguments(), foundPosition)); + } + + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedImpl( + final InstanceIdentifier binding) { + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath = bindingToLegacy + .toDataDom(binding); + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = legacyToNormalized + .toNormalized(legacyPath); + return normalized; + } + + private static boolean isAugmentation(final Class type) { + return Augmentation.class.isAssignableFrom(type); + } + + private static boolean isAugmentationIdentifier(final InstanceIdentifier potential) { + return Augmentation.class.isAssignableFrom(potential.getTargetType()); + } + + private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed) { + return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier; + } + + private static int getAugmentationCount(final InstanceIdentifier potential) { + int count = 0; + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : potential.getPathArguments()) { + if (isAugmentation(arg.getType())) { + count++; + } + + } + return count; + } + + private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potential) { + int count = 0; + for (PathArgument arg : potential.getPathArguments()) { + if (arg instanceof AugmentationIdentifier) { + count++; + } + } + return count; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { - return codecRegistry.deserializeFunction(path); + return new DeserializeFunction(this, path); + } + + private static class DeserializeFunction implements Function>, Optional> { + + private final BindingToNormalizedNodeCodec codec; + private final InstanceIdentifier path; + + public DeserializeFunction(final BindingToNormalizedNodeCodec codec, final InstanceIdentifier path) { + super(); + this.codec = Preconditions.checkNotNull(codec, "Codec must not be null"); + this.path = Preconditions.checkNotNull(path, "Path must not be null"); + } + + @SuppressWarnings("rawtypes") + @Nullable + @Override + public Optional apply(@Nullable final Optional> normalizedNode) { + if (normalizedNode.isPresent()) { + final DataObject dataObject; + try { + dataObject = codec.toBinding(path, normalizedNode.get()); + } catch (DeserializationException e) { + LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e); + throw new IllegalStateException("Failed to create dataobject", e); + } + + if (dataObject != null) { + return Optional.of(dataObject); + } + } + return Optional.absent(); + } } /** @@ -136,13 +566,4 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC } return currentOp.createDefault(path.getLastPathArgument()); } - - public BindingIndependentMappingService getLegacy() { - return bindingToLegacy; - } - - @Override - public void close() throws Exception { - // NOOP Intentionally - } } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java index 52e114b0ea..237d9678f9 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java @@ -7,12 +7,6 @@ */ package org.opendaylight.controller.md.sal.binding.impl; -import com.google.common.base.Function; -import com.google.common.util.concurrent.AsyncFunction; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.common.util.concurrent.ListeningExecutorService; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; @@ -23,6 +17,7 @@ import java.util.Set; import java.util.concurrent.Callable; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutionException; + import org.opendaylight.controller.md.sal.common.api.RegistrationListener; import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; @@ -49,9 +44,17 @@ import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Function; +import com.google.common.util.concurrent.AsyncFunction; +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; + @SuppressWarnings("deprecation") public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDataBroker implements DataProviderService, AutoCloseable { @@ -61,7 +64,7 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat private final ListeningExecutorService executorService; public ForwardedBackwardsCompatibleDataBroker(final DOMDataBroker domDataBroker, - final BindingToNormalizedNodeCodec mappingService, final SchemaService schemaService,final ListeningExecutorService executor) { + final BindingIndependentMappingService mappingService, final SchemaService schemaService,final ListeningExecutorService executor) { super(domDataBroker, mappingService,schemaService); executorService = executor; LOG.info("ForwardedBackwardsCompatibleBroker started."); diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java index ef66d80ed4..6359b60684 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java @@ -16,6 +16,7 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; /** * The DataBrokerImpl simply defers to the DOMDataBroker for all its operations. @@ -29,8 +30,8 @@ import org.opendaylight.controller.sal.core.api.model.SchemaService; */ public class ForwardedBindingDataBroker extends AbstractForwardedDataBroker implements DataBroker { - public ForwardedBindingDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec, final SchemaService schemaService) { - super(domDataBroker, codec,schemaService); + public ForwardedBindingDataBroker(final DOMDataBroker domDataBroker, final BindingIndependentMappingService mappingService, final SchemaService schemaService) { + super(domDataBroker, mappingService,schemaService); } @Override diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java index f037e679be..1ec4aa2d30 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java @@ -7,10 +7,6 @@ */ package org.opendaylight.controller.sal.binding.codegen.impl; -import com.google.common.util.concurrent.ForwardingBlockingQueue; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; -import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -20,19 +16,24 @@ import java.util.concurrent.RejectedExecutionHandler; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; + import javassist.ClassPool; + import org.apache.commons.lang3.StringUtils; import org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator; import org.opendaylight.controller.sal.binding.spi.NotificationInvokerFactory; -import org.opendaylight.yangtools.sal.binding.generator.util.JavassistUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.util.concurrent.ForwardingBlockingQueue; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import com.google.common.util.concurrent.ThreadFactoryBuilder; + public class SingletonHolder { private static final Logger logger = LoggerFactory.getLogger(SingletonHolder.class); public static final ClassPool CLASS_POOL = ClassPool.getDefault(); - public static final JavassistUtils JAVASSIST = JavassistUtils.forClassPool(CLASS_POOL); public static final org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator RPC_GENERATOR_IMPL = new org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator( CLASS_POOL); public static final RuntimeCodeGenerator RPC_GENERATOR = RPC_GENERATOR_IMPL; diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RootDataBrokerImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RootDataBrokerImpl.java new file mode 100644 index 0000000000..a1cae266c1 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RootDataBrokerImpl.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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; + +import org.opendaylight.controller.config.yang.md.sal.binding.impl.Data; +import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplRuntimeMXBean; +import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplRuntimeRegistration; +import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplRuntimeRegistrator; +import org.opendaylight.controller.config.yang.md.sal.binding.impl.Transactions; +import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector; + +public class RootDataBrokerImpl extends DataBrokerImpl implements DataBrokerImplRuntimeMXBean { + + private final Transactions transactions = new Transactions(); + private final Data data = new Data(); + private BindingIndependentConnector bindingIndependentConnector; + private DataBrokerImplRuntimeRegistration runtimeBeanRegistration; + + public BindingIndependentConnector getBindingIndependentConnector() { + return bindingIndependentConnector; + } + + public Transactions getTransactions() { + transactions.setCreated(getCreatedTransactionsCount().get()); + transactions.setSubmitted(getSubmittedTransactionsCount().get()); + transactions.setSuccessful(getFinishedTransactionsCount().get()); + transactions.setFailed(getFailedTransactionsCount().get()); + return transactions; + } + + @Override + public Data getData() { + data.setTransactions(getTransactions()); + return data; + } + + public void setBindingIndependentConnector(BindingIndependentConnector runtimeMapping) { + this.bindingIndependentConnector = runtimeMapping; + } + + public void registerRuntimeBean(DataBrokerImplRuntimeRegistrator rootRegistrator) { + runtimeBeanRegistration = rootRegistrator.register(this); + } + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/forward/DomForwardedDataBrokerImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/forward/DomForwardedDataBrokerImpl.java new file mode 100644 index 0000000000..3d0e4deb65 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/forward/DomForwardedDataBrokerImpl.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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.forward; + +import java.util.Collection; +import java.util.Collections; + +import org.opendaylight.controller.sal.binding.impl.RootDataBrokerImpl; +import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer; +import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector; +import org.opendaylight.controller.sal.core.api.Provider; +import org.opendaylight.controller.sal.core.api.Broker.ProviderSession; + +public class DomForwardedDataBrokerImpl extends RootDataBrokerImpl implements Provider, DomForwardedBroker { + + private BindingIndependentConnector connector; + private ProviderSession domProviderContext; + + public void setConnector(BindingIndependentConnector connector) { + this.connector = connector; + } + + @Override + public void onSessionInitiated(ProviderSession session) { + this.setDomProviderContext(session); + } + + @Override + public Collection getProviderFunctionality() { + return Collections.emptySet(); + } + + @Override + public BindingIndependentConnector getConnector() { + return connector; + } + + @Override + public ProviderSession getDomProviderContext() { + return domProviderContext; + } + + public void setDomProviderContext(ProviderSession domProviderContext) { + this.domProviderContext = domProviderContext; + } + + @Override + public void startForwarding() { + BindingDomConnectorDeployer.startDataForwarding(getConnector(), this, getDomProviderContext()); + } +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/yang/opendaylight-binding-broker-impl.yang b/opendaylight/md-sal/sal-binding-broker/src/main/yang/opendaylight-binding-broker-impl.yang index aec2723591..cee4b1efb3 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/yang/opendaylight-binding-broker-impl.yang +++ b/opendaylight/md-sal/sal-binding-broker/src/main/yang/opendaylight-binding-broker-impl.yang @@ -18,9 +18,10 @@ module opendaylight-sal-binding-broker-impl { identity binding-dom-mapping-service { base config:service-type; - config:java-class "org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec"; + config:java-class "org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService"; } + identity binding-broker-impl { base config:module-type; config:provided-service sal:binding-broker-osgi-registry; @@ -28,6 +29,13 @@ module opendaylight-sal-binding-broker-impl { config:java-name-prefix BindingBrokerImpl; } + identity binding-data-broker { + base config:module-type; + config:provided-service sal:binding-data-broker; + config:provided-service sal:binding-data-consumer-broker; + config:java-name-prefix DataBrokerImpl; + } + identity binding-data-compatible-broker { base config:module-type; config:provided-service sal:binding-data-broker; @@ -123,6 +131,29 @@ module opendaylight-sal-binding-broker-impl { } } + augment "/config:modules/config:module/config:configuration" { + case binding-data-broker { + when "/config:modules/config:module/config:type = 'binding-data-broker'"; + container dom-broker { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity dom:dom-broker-osgi-registry; + } + } + } + + container mapping-service { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity binding-dom-mapping-service; + } + } + } + } + } + augment "/config:modules/config:module/config:configuration" { case binding-data-compatible-broker { when "/config:modules/config:module/config:type = 'binding-data-compatible-broker'"; @@ -147,6 +178,14 @@ module opendaylight-sal-binding-broker-impl { } } + augment "/config:modules/config:module/config:state" { + case binding-data-broker { + when "/config:modules/config:module/config:type = 'binding-data-broker'"; + container data { + uses common:data-state; + } + } + } augment "/config:modules/config:module/config:state" { case binding-rpc-broker { when "/config:modules/config:module/config:type = 'binding-rpc-broker'"; diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java index 815fc45259..fd0a169694 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java @@ -1,8 +1,8 @@ package org.opendaylight.controller.md.sal.binding.impl.test; import static org.junit.Assert.assertTrue; - import javassist.ClassPool; + import org.junit.Test; import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; import org.opendaylight.controller.md.sal.binding.test.AbstractSchemaAwareTest; @@ -11,11 +11,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controll import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator; -import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; -import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl; -import org.opendaylight.yangtools.sal.binding.generator.util.JavassistUtils; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; @@ -38,9 +34,7 @@ public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest { @Override protected void setupWithSchema(final SchemaContext context) { mappingService = new RuntimeGeneratedMappingServiceImpl(ClassPool.getDefault()); - StreamWriterGenerator streamWriter = new StreamWriterGenerator(JavassistUtils.forClassPool(ClassPool.getDefault())); - BindingNormalizedNodeCodecRegistry registry = new BindingNormalizedNodeCodecRegistry(streamWriter); - codec = new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mappingService, registry); + codec = new BindingToNormalizedNodeCodec(mappingService); mappingService.onGlobalContextUpdated(context); codec.onGlobalContextUpdated(context); }; diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java index 106fcea0e9..60eec55ca5 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java @@ -7,14 +7,9 @@ */ package org.opendaylight.controller.md.sal.binding.test; -import com.google.common.collect.ImmutableMap; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; - import javassist.ClassPool; import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; import org.opendaylight.controller.md.sal.binding.impl.ForwardedBackwardsCompatibleDataBroker; import org.opendaylight.controller.md.sal.binding.impl.ForwardedBindingDataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; @@ -24,22 +19,20 @@ import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore; import org.opendaylight.controller.sal.binding.test.util.MockSchemaService; import org.opendaylight.controller.sal.core.api.model.SchemaService; import org.opendaylight.controller.sal.core.spi.data.DOMStore; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.DataObjectSerializerGenerator; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator; -import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; -import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl; -import org.opendaylight.yangtools.sal.binding.generator.util.JavassistUtils; import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import com.google.common.collect.ImmutableMap; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; + public class DataBrokerTestCustomizer { private DOMDataBroker domDataBroker; private final RuntimeGeneratedMappingServiceImpl mappingService; private final MockSchemaService schemaService; private ImmutableMap datastores; - private final BindingToNormalizedNodeCodec bindingToNormalized ; public ImmutableMap createDatastores() { return ImmutableMap.builder() @@ -50,13 +43,7 @@ public class DataBrokerTestCustomizer { public DataBrokerTestCustomizer() { schemaService = new MockSchemaService(); - ClassPool pool = ClassPool.getDefault(); - mappingService = new RuntimeGeneratedMappingServiceImpl(pool); - DataObjectSerializerGenerator generator = StreamWriterGenerator.create(JavassistUtils.forClassPool(pool)); - BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(generator); - GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(); - bindingToNormalized = new BindingToNormalizedNodeCodec(loading, mappingService, codecRegistry); - schemaService.registerSchemaContextListener(bindingToNormalized); + mappingService = new RuntimeGeneratedMappingServiceImpl(ClassPool.getDefault()); } public DOMStore createConfigurationDatastore() { @@ -82,13 +69,14 @@ public class DataBrokerTestCustomizer { } public DataBroker createDataBroker() { - return new ForwardedBindingDataBroker(getDOMDataBroker(), bindingToNormalized, schemaService ); + return new ForwardedBindingDataBroker(getDOMDataBroker(), getMappingService(), getSchemaService()); } public ForwardedBackwardsCompatibleDataBroker createBackwardsCompatibleDataBroker() { - return new ForwardedBackwardsCompatibleDataBroker(getDOMDataBroker(), bindingToNormalized, getSchemaService(), MoreExecutors.sameThreadExecutor()); + return new ForwardedBackwardsCompatibleDataBroker(getDOMDataBroker(), getMappingService(), getSchemaService(), MoreExecutors.sameThreadExecutor()); } + private SchemaService getSchemaService() { return schemaService; } diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/compat/MultipleAugmentationPutsTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/compat/MultipleAugmentationPutsTest.java index 63e0e2290a..7b67d3b10f 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/compat/MultipleAugmentationPutsTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/compat/MultipleAugmentationPutsTest.java @@ -16,6 +16,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; + import org.junit.Test; import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent; @@ -75,7 +76,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem * * @throws Exception */ - @Test() + @Test( timeout = 15000) public void testAugmentSerialization() throws Exception { baDataService.registerDataChangeListener(NODES_INSTANCE_ID_BA, this); @@ -121,7 +122,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem testNodeRemove(); } - private > Node createTestNode(final Class augmentationClass, final T augmentation) { + private > Node createTestNode(Class augmentationClass, T augmentation) { NodeBuilder nodeBuilder = new NodeBuilder(); nodeBuilder.setId(new NodeId(NODE_ID)); nodeBuilder.setKey(NODE_KEY); @@ -129,7 +130,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem return nodeBuilder.build(); } - private DataModificationTransaction commitNodeAndVerifyTransaction(final Node original) throws Exception { + private DataModificationTransaction commitNodeAndVerifyTransaction(Node original) throws Exception { DataModificationTransaction transaction = baDataService.beginTransaction(); transaction.putOperationalData(NODE_INSTANCE_ID_BA, original); RpcResult result = transaction.commit().get(); @@ -147,7 +148,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem assertNull(node); } - private AugmentationVerifier verifyNode(final Nodes nodes, final Node original) { + private AugmentationVerifier verifyNode(Nodes nodes, Node original) { assertNotNull(nodes); assertNotNull(nodes.getNode()); assertEquals(1, nodes.getNode().size()); @@ -157,7 +158,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem return new AugmentationVerifier(readedNode); } - private void assertBindingIndependentVersion(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier nodeId) { + private void assertBindingIndependentVersion(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier nodeId) { CompositeNode node = biDataService.readOperationalData(nodeId); assertNotNull(node); } @@ -170,7 +171,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem return nodeMeterStatistics(10, false); } - private NodeMeterStatistics nodeMeterStatistics(final int count, final boolean setDuration) { + private NodeMeterStatistics nodeMeterStatistics(int count, boolean setDuration) { NodeMeterStatisticsBuilder nmsb = new NodeMeterStatisticsBuilder(); MeterStatisticsBuilder meterStats = new MeterStatisticsBuilder(); @@ -206,7 +207,7 @@ public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implem } @Override - public void onDataChanged(final DataChangeEvent, DataObject> change) { + public void onDataChanged(DataChangeEvent, DataObject> change) { receivedChangeEvent = change; } diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java index d0a326adff..fef5715f50 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java @@ -9,19 +9,12 @@ package org.opendaylight.controller.sal.binding.test.util; import static com.google.common.base.Preconditions.checkState; -import com.google.common.annotations.Beta; -import com.google.common.collect.ClassToInstanceMap; -import com.google.common.collect.ImmutableClassToInstanceMap; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.MutableClassToInstanceMap; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; import java.util.Set; import java.util.concurrent.Future; + import javassist.ClassPool; + import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; import org.opendaylight.controller.md.sal.binding.impl.ForwardedBackwardsCompatibleDataBroker; import org.opendaylight.controller.md.sal.binding.impl.ForwardedBindingDataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; @@ -50,14 +43,9 @@ import org.opendaylight.controller.sal.core.spi.data.DOMStore; import org.opendaylight.controller.sal.dom.broker.BrokerImpl; import org.opendaylight.controller.sal.dom.broker.MountPointManagerImpl; import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.DataObjectSerializerGenerator; -import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator; -import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; import org.opendaylight.yangtools.concepts.ListenerRegistration; -import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl; -import org.opendaylight.yangtools.sal.binding.generator.util.JavassistUtils; import org.opendaylight.yangtools.yang.binding.YangModuleInfo; import org.opendaylight.yangtools.yang.binding.util.BindingReflections; import org.opendaylight.yangtools.yang.common.QName; @@ -68,6 +56,15 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.annotations.Beta; +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.ImmutableClassToInstanceMap; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.MutableClassToInstanceMap; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; + @Beta public class BindingTestContext implements AutoCloseable { @@ -77,7 +74,6 @@ public class BindingTestContext implements AutoCloseable { private static final Logger LOG = LoggerFactory.getLogger(BindingTestContext.class); private RuntimeGeneratedMappingServiceImpl mappingServiceImpl; - private BindingToNormalizedNodeCodec codec; private DomForwardedBindingBrokerImpl baBrokerImpl; private DataBrokerImpl baDataImpl; @@ -133,7 +129,7 @@ public class BindingTestContext implements AutoCloseable { public void startNewDataBroker() { checkState(executor != null, "Executor needs to be set"); checkState(newDOMDataBroker != null, "DOM Data Broker must be set"); - dataBroker = new ForwardedBindingDataBroker(newDOMDataBroker, codec, mockSchemaService); + dataBroker = new ForwardedBindingDataBroker(newDOMDataBroker, mappingServiceImpl, mockSchemaService); } public void startNewDomDataBroker() { @@ -254,12 +250,6 @@ public class BindingTestContext implements AutoCloseable { checkState(classPool != null, "ClassPool needs to be present"); mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl(classPool); mockSchemaService.registerSchemaContextListener(mappingServiceImpl); - - DataObjectSerializerGenerator generator = StreamWriterGenerator.create(JavassistUtils.forClassPool(classPool)); - BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(generator); - GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(); - codec = new BindingToNormalizedNodeCodec(loading, mappingServiceImpl, codecRegistry); - mockSchemaService.registerSchemaContextListener(codec); } private void updateYangSchema(final ImmutableSet moduleInfos) { @@ -290,7 +280,7 @@ public class BindingTestContext implements AutoCloseable { } public void startNewBindingDataBroker() { - ForwardedBackwardsCompatibleDataBroker forwarded = new ForwardedBackwardsCompatibleDataBroker(newDOMDataBroker, codec,mockSchemaService, executor); + ForwardedBackwardsCompatibleDataBroker forwarded = new ForwardedBackwardsCompatibleDataBroker(newDOMDataBroker, mappingServiceImpl,mockSchemaService, executor); baData = forwarded; } diff --git a/opendaylight/md-sal/sal-binding-it/src/main/java/org/opendaylight/controller/test/sal/binding/it/TestHelper.java b/opendaylight/md-sal/sal-binding-it/src/main/java/org/opendaylight/controller/test/sal/binding/it/TestHelper.java index 344694381a..83a69969b7 100644 --- a/opendaylight/md-sal/sal-binding-it/src/main/java/org/opendaylight/controller/test/sal/binding/it/TestHelper.java +++ b/opendaylight/md-sal/sal-binding-it/src/main/java/org/opendaylight/controller/test/sal/binding/it/TestHelper.java @@ -112,7 +112,6 @@ public class TestHelper { mavenBundle(YANGTOOLS, "binding-generator-api").versionAsInProject(), mavenBundle(YANGTOOLS, "binding-generator-spi").versionAsInProject(), // mavenBundle(YANGTOOLS, "binding-generator-impl").versionAsInProject(), - mavenBundle(YANGTOOLS, "binding-data-codec").versionAsInProject(), mavenBundle(YANGTOOLS + ".thirdparty", "antlr4-runtime-osgi-nohead").versionAsInProject(), // // mavenBundle(CONTROLLER, "sal-core-api").versionAsInProject().update(), // diff --git a/opendaylight/md-sal/sal-binding-it/src/test/java/org/opendaylight/controller/test/sal/binding/it/DataServiceTest.java b/opendaylight/md-sal/sal-binding-it/src/test/java/org/opendaylight/controller/test/sal/binding/it/DataServiceTest.java index 33039ea231..8a390b337e 100644 --- a/opendaylight/md-sal/sal-binding-it/src/test/java/org/opendaylight/controller/test/sal/binding/it/DataServiceTest.java +++ b/opendaylight/md-sal/sal-binding-it/src/test/java/org/opendaylight/controller/test/sal/binding/it/DataServiceTest.java @@ -11,10 +11,9 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; -import com.google.inject.Inject; import java.util.concurrent.Future; + import org.junit.Before; -import org.junit.Ignore; import org.junit.Test; import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext; @@ -23,6 +22,7 @@ import org.opendaylight.controller.sal.binding.api.data.DataBrokerService; import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction; import org.opendaylight.controller.sal.core.api.Broker; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder; @@ -31,6 +31,8 @@ import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; +import com.google.inject.Inject; + public class DataServiceTest extends AbstractTest { protected DataBrokerService consumerDataService; @@ -43,20 +45,12 @@ public class DataServiceTest extends AbstractTest { public void setUp() throws Exception { } - /* - * - * Ignored this, because classes here are constructed from - * very different class loader as MD-SAL is run into, - * this is code is run from different classloader. - * - */ @Test - @Ignore public void test() throws Exception { BindingAwareConsumer consumer1 = new BindingAwareConsumer() { @Override - public void onSessionInitialized(final ConsumerContext session) { + public void onSessionInitialized(ConsumerContext session) { consumerDataService = session.getSALService(DataBrokerService.class); } }; @@ -68,12 +62,12 @@ public class DataServiceTest extends AbstractTest { DataModificationTransaction transaction = consumerDataService.beginTransaction(); assertNotNull(transaction); - InstanceIdentifier node1 = createNodeRef("0"); - DataObject node = consumerDataService.readConfigurationData(node1); + NodeRef node1 = createNodeRef("0"); + DataObject node = consumerDataService.readConfigurationData(node1.getValue()); assertNull(node); Node nodeData1 = createNode("0"); - transaction.putConfigurationData(node1, nodeData1); + transaction.putConfigurationData(node1.getValue(), nodeData1); Future> commitResult = transaction.commit(); assertNotNull(commitResult); @@ -83,7 +77,7 @@ public class DataServiceTest extends AbstractTest { assertNotNull(result.getResult()); assertEquals(TransactionStatus.COMMITED, result.getResult()); - Node readedData = (Node) consumerDataService.readConfigurationData(node1); + Node readedData = (Node) consumerDataService.readConfigurationData(node1.getValue()); assertNotNull(readedData); assertEquals(nodeData1.getKey(), readedData.getKey()); @@ -91,7 +85,7 @@ public class DataServiceTest extends AbstractTest { DataModificationTransaction transaction2 = consumerDataService.beginTransaction(); assertNotNull(transaction); - transaction2.removeConfigurationData(node1); + transaction2.removeConfigurationData(node1.getValue()); Future> commitResult2 = transaction2.commit(); assertNotNull(commitResult2); @@ -102,19 +96,21 @@ public class DataServiceTest extends AbstractTest { assertNotNull(result2.getResult()); assertEquals(TransactionStatus.COMMITED, result2.getResult()); - DataObject readedData2 = consumerDataService.readConfigurationData(node1); + DataObject readedData2 = consumerDataService.readConfigurationData(node1.getValue()); assertNull(readedData2); } - private static InstanceIdentifier createNodeRef(final String string) { + private static NodeRef createNodeRef(String string) { NodeKey key = new NodeKey(new NodeId(string)); - return InstanceIdentifier.builder(Nodes.class).child(Node.class, key).build(); + InstanceIdentifier path = InstanceIdentifier.builder(Nodes.class).child(Node.class, key).build(); + + return new NodeRef(path); } - private static Node createNode(final String string) { + private static Node createNode(String string) { NodeBuilder ret = new NodeBuilder(); NodeId id = new NodeId(string); ret.setKey(new NodeKey(id)); diff --git a/opendaylight/md-sal/sal-binding-it/src/test/resources/controller.xml b/opendaylight/md-sal/sal-binding-it/src/test/resources/controller.xml index 5e37f36a2c..63a921d6f3 100644 --- a/opendaylight/md-sal/sal-binding-it/src/test/resources/controller.xml +++ b/opendaylight/md-sal/sal-binding-it/src/test/resources/controller.xml @@ -38,104 +38,124 @@ - prefix:schema-service-singleton + + prefix:schema-service-singleton + yang-schema-service - prefix:runtime-generated-mapping - runtime-mapping-singleton + + prefix:hash-map-data-store + + hash-map-data-store - prefix:binding-notification-broker - binding-notification-broker + + prefix:dom-broker-impl + + dom-broker + + + dom:dom-data-store + + ref_hash-map-data-store + - prefix:binding-broker-impl + + prefix:binding-broker-impl + binding-broker-impl - - binding:binding-notification-service - binding-notification-broker + + + binding:binding-notification-service + + ref_binding-notification-broker - binding:binding-data-broker - binding-data-broker + + binding:binding-data-broker + + ref_binding-data-broker - - - prefix:dom-inmemory-data-broker - inmemory-data-broker - - dom:schema-service - yang-schema-service - - - prefix:dom-broker-impl - inmemory-dom-broker - - dom:dom-async-data-broker - inmemory-data-broker - + + prefix:runtime-generated-mapping + + runtime-mapping-singleton - prefix:binding-data-compatible-broker - inmemory-binding-data-broker - - dom:dom-broker-osgi-registry - dom-broker - - - binding:binding-dom-mapping-service - runtime-mapping-singleton - + + prefix:binding-notification-broker + + binding-notification-broker - prefix:binding-forwarded-data-broker - binding-async-data-broker - - - dom:dom-broker-osgi-registry - dom-broker - - - binding:binding-dom-mapping-service - runtime-mapping-singleton - - + + prefix:binding-data-broker + + binding-data-broker + + + dom:dom-broker-osgi-registry + + ref_dom-broker + + + + binding:binding-dom-mapping-service + + ref_runtime-mapping-singleton + - dom:schema-service + + dom:schema-service + - yang-schema-service - /modules/module[type='schema-service-singleton'][name='yang-schema-service'] + ref_yang-schema-service + + /config/modules/module[name='schema-service-singleton']/instance[name='yang-schema-service'] + - binding-impl:binding-dom-mapping-service + + binding:binding-notification-service + - runtime-mapping-singleton - /modules/module[type='runtime-generated-mapping'][name='runtime-mapping-singleton'] + ref_binding-notification-broker + + /config/modules/module[name='binding-notification-broker']/instance[name='binding-notification-broker'] + - binding:binding-notification-service + + dom:dom-data-store + - binding-notification-broker - /modules/module[type='binding-notification-broker'][name='binding-notification-broker'] + ref_hash-map-data-store + + /config/modules/module[name='hash-map-data-store']/instance[name='hash-map-data-store'] + + - binding:binding-broker-osgi-registry + + binding:binding-broker-osgi-registry + - binding-osgi-broker - /modules/module[type='binding-broker-impl'][name='binding-broker-impl'] + ref_binding-broker-impl + + /config/modules/module[name='binding-broker-impl']/instance[name='binding-broker-impl'] + @@ -145,36 +165,36 @@ /modules/module[type='binding-broker-impl'][name='binding-broker-impl'] - - - dom:dom-broker-osgi-registry - - dom-broker - /modules/module[type='dom-broker-impl'][name='inmemory-dom-broker'] - - - - binding:binding-data-broker + + binding-impl:binding-dom-mapping-service + - binding-data-broker - /modules/module[type='binding-data-compatible-broker'][name='inmemory-binding-data-broker'] + ref_runtime-mapping-singleton + + /config/modules/module[name='runtime-generated-mapping']/instance[name='runtime-mapping-singleton'] + - - binding:binding-async-data-broker + + dom:dom-broker-osgi-registry + - binding-data-broker - /modules/module[type='binding-forwarded-data-broker'][name='binding-async-data-broker'] + ref_dom-broker + /config/modules/module[name='dom-broker-impl']/instance[name='dom-broker'] + - - dom:dom-async-data-broker + + binding:binding-data-broker + - inmemory-data-broker - /modules/module[type='dom-inmemory-data-broker'][name='inmemory-data-broker'] + ref_binding-data-broker + + /config/modules/module[name='binding-data-broker']/instance[name='binding-data-broker'] + -- 2.36.6