X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fbinding%2Fimpl%2FAbstractForwardedDataBroker.java;h=2d81b6022d35af1c70fba4adb269ffc2d8c93dce;hp=b09cd1c80a142e629493180a47640fb0a5d894a4;hb=da676b1719581aa69348c97196715b6b922daa5b;hpb=bef0749bb2517eaae6a501be501e16a7d3905045 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 b09cd1c80a..82cbf087c8 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 @@ -7,70 +7,55 @@ */ package org.opendaylight.controller.md.sal.binding.impl; +import com.google.common.base.MoreObjects; +import com.google.common.base.Optional; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; import java.util.Set; - -import org.opendaylight.controller.md.sal.binding.api.BindingDataChangeListener; +import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener; +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; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataChangeListener; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener; -import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector; -import org.opendaylight.controller.sal.binding.impl.forward.DomForwardedBroker; -import org.opendaylight.controller.sal.core.api.Broker.ProviderSession; -import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.mdsal.dom.api.DOMSchemaService; import org.opendaylight.yangtools.concepts.AbstractListenerRegistration; import org.opendaylight.yangtools.concepts.Delegator; import org.opendaylight.yangtools.concepts.ListenerRegistration; 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.opendaylight.yangtools.yang.model.api.SchemaServiceListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Objects; -import com.google.common.base.Optional; - -public abstract class AbstractForwardedDataBroker implements Delegator, DomForwardedBroker, - SchemaContextListener, AutoCloseable { +public abstract class AbstractForwardedDataBroker implements Delegator, 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 BindingIndependentMappingService mappingService,final SchemaService schemaService) { + protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec, + final DOMSchemaService schemaService) { this.domDataBroker = domDataBroker; - this.mappingService = mappingService; - this.codec = new BindingToNormalizedNodeCodec(mappingService); - this.schemaListenerRegistration = schemaService.registerSchemaServiceListener(this); + this.codec = codec; } - protected BindingToNormalizedNodeCodec getCodec() { - return codec; + protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec) { + this.domDataBroker = domDataBroker; + this.codec = codec; } - protected BindingIndependentMappingService getMappingService() { - return mappingService; + protected BindingToNormalizedNodeCodec getCodec() { + return codec; } @Override @@ -78,52 +63,53 @@ public abstract class AbstractForwardedDataBroker implements Delegator registerDataChangeListener(final LogicalDatastoreType store, + final InstanceIdentifier path, final DataChangeListener listener, final DataChangeScope triggeringScope) { + final DOMDataChangeListener domDataChangeListener; - public ListenerRegistration registerDataChangeListener(final LogicalDatastoreType store, - final InstanceIdentifier path, final BindingDataChangeListener listener, - final DataChangeScope triggeringScope) { - DOMDataChangeListener domDataChangeListener = new TranslatingDataChangeInvoker(store, path, listener, + if(listener instanceof ClusteredDataChangeListener) { + domDataChangeListener = new TranslatingClusteredDataChangeInvoker(store, path, listener, triggeringScope); + } else { + domDataChangeListener = new TranslatingDataChangeInvoker(store, path, listener, triggeringScope); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = codec.toNormalized(path); - ListenerRegistration domRegistration = domDataBroker.registerDataChangeListener(store, + } + final YangInstanceIdentifier domPath = codec.toYangInstanceIdentifierBlocking(path); + final ListenerRegistration domRegistration = domDataBroker.registerDataChangeListener(store, domPath, domDataChangeListener, triggeringScope); return new ListenerRegistrationImpl(listener, domRegistration); } - protected Map, DataObject> toBinding( - final Map> normalized) { - Map, DataObject> newMap = new HashMap<>(); - for (Map.Entry> entry : normalized - .entrySet()) { + protected Map, DataObject> toBinding(final InstanceIdentifier path, + final Map> normalized) { + final Map, DataObject> newMap = new HashMap<>(); + + for (final Map.Entry> entry : normalized.entrySet()) { try { - Optional, DataObject>> potential = getCodec().toBinding( - entry); + final Optional, DataObject>> potential = getCodec().toBinding(entry); if (potential.isPresent()) { - Entry, DataObject> binding = potential.get(); + final Entry, DataObject> binding = potential.get(); newMap.put(binding.getKey(), binding.getValue()); } - } catch (DeserializationException e) { + } catch (final DeserializationException e) { LOG.warn("Failed to transform {}, omitting it", entry, e); } } return newMap; } - protected Set> toBinding( - final Set normalized) { - Set> hashSet = new HashSet<>(); - for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath : normalized) { + protected Set> toBinding(final InstanceIdentifier path, + final Set normalized) { + final Set> hashSet = new HashSet<>(); + for (final YangInstanceIdentifier normalizedPath : normalized) { try { - Optional> potential = getCodec().toBinding(normalizedPath); + final Optional> potential = getCodec().toBinding(normalizedPath); if (potential.isPresent()) { - InstanceIdentifier binding = potential.get(); + final InstanceIdentifier binding = potential.get(); hashSet.add(binding); + } else if (normalizedPath.getLastPathArgument() instanceof YangInstanceIdentifier.AugmentationIdentifier) { + hashSet.add(path); } - } catch (DeserializationException e) { + } catch (final DeserializationException e) { LOG.warn("Failed to transform {}, omitting it", normalizedPath, e); } } @@ -134,22 +120,17 @@ public abstract class AbstractForwardedDataBroker implements Delegator) getCodec().deserializeFunction(path).apply(Optional.> of(data)); } private class TranslatingDataChangeInvoker implements DOMDataChangeListener { - private final BindingDataChangeListener bindingDataChangeListener; + private final DataChangeListener bindingDataChangeListener; private final LogicalDatastoreType store; private final InstanceIdentifier path; private final DataChangeScope triggeringScope; public TranslatingDataChangeInvoker(final LogicalDatastoreType store, final InstanceIdentifier path, - final BindingDataChangeListener bindingDataChangeListener, final DataChangeScope triggeringScope) { + final DataChangeListener bindingDataChangeListener, final DataChangeScope triggeringScope) { this.store = store; this.path = path; this.bindingDataChangeListener = bindingDataChangeListener; @@ -157,25 +138,43 @@ public abstract class AbstractForwardedDataBroker implements Delegator> change) { + public void onDataChanged(final AsyncDataChangeEvent> change) { bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change, path)); } + + @Override + public String toString() { + return bindingDataChangeListener.getClass().getName(); + } + } + + /** + * Translator for ClusteredDataChangeListener + */ + + private class TranslatingClusteredDataChangeInvoker extends TranslatingDataChangeInvoker implements + ClusteredDOMDataChangeListener { + + public TranslatingClusteredDataChangeInvoker(final LogicalDatastoreType store, final InstanceIdentifier path, + final DataChangeListener bindingDataChangeListener, + final DataChangeScope triggeringScope) { + super(store, path, bindingDataChangeListener, triggeringScope); + } } private class TranslatedDataChangeEvent implements AsyncDataChangeEvent, DataObject> { - private final AsyncDataChangeEvent> domEvent; + private final AsyncDataChangeEvent> domEvent; private final InstanceIdentifier path; private Map, DataObject> createdCache; private Map, DataObject> updatedCache; - private Map, ? extends DataObject> originalCache; + private Map, DataObject> originalCache; private Set> removedCache; private Optional originalDataCache; private Optional updatedDataCache; public TranslatedDataChangeEvent( - final AsyncDataChangeEvent> change, + final AsyncDataChangeEvent> change, final InstanceIdentifier path) { this.domEvent = change; this.path = path; @@ -184,7 +183,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator, DataObject> getCreatedData() { if (createdCache == null) { - createdCache = Collections.unmodifiableMap(toBinding(domEvent.getCreatedData())); + createdCache = Collections.unmodifiableMap(toBinding(path, domEvent.getCreatedData())); } return createdCache; } @@ -192,7 +191,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator, DataObject> getUpdatedData() { if (updatedCache == null) { - updatedCache = Collections.unmodifiableMap(toBinding(domEvent.getUpdatedData())); + updatedCache = Collections.unmodifiableMap(toBinding(path, domEvent.getUpdatedData())); } return updatedCache; @@ -201,15 +200,15 @@ public abstract class AbstractForwardedDataBroker implements Delegator> getRemovedPaths() { if (removedCache == null) { - removedCache = Collections.unmodifiableSet(toBinding(domEvent.getRemovedPaths())); + removedCache = Collections.unmodifiableSet(toBinding(path, domEvent.getRemovedPaths())); } return removedCache; } @Override - public Map, ? extends DataObject> getOriginalData() { + public Map, DataObject> getOriginalData() { if (originalCache == null) { - originalCache = Collections.unmodifiableMap(toBinding(domEvent.getOriginalData())); + originalCache = Collections.unmodifiableMap(toBinding(path, domEvent.getOriginalData())); } return originalCache; @@ -218,7 +217,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator { + private static class ListenerRegistrationImpl extends AbstractListenerRegistration { private final ListenerRegistration registration; - public ListenerRegistrationImpl(final BindingDataChangeListener listener, + public ListenerRegistrationImpl(final DataChangeListener listener, final ListenerRegistration registration) { super(listener); this.registration = registration; @@ -266,33 +265,7 @@ public abstract class AbstractForwardedDataBroker implements Delegator