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=8a32b0b3026f1d028dbab77a00e6c54be22d07ad;hb=da676b1719581aa69348c97196715b6b922daa5b;hpb=721b580748cb93b3dac952ff1f111d0ab0da0c79 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 8a32b0b302..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,62 +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.eclipse.xtext.xbase.lib.Exceptions; -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.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.slf4j.Logger; import org.slf4j.LoggerFactory; -public abstract class AbstractForwardedDataBroker implements Delegator, DomForwardedBroker, SchemaContextListener { +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; - protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, - final BindingIndependentMappingService mappingService) { + protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec, + final DOMSchemaService schemaService) { this.domDataBroker = domDataBroker; - this.mappingService = mappingService; - this.codec = new BindingToNormalizedNodeCodec(mappingService); + 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 @@ -70,44 +63,74 @@ 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, domPath, domDataChangeListener, triggeringScope); + } + final YangInstanceIdentifier domPath = codec.toYangInstanceIdentifierBlocking(path); + final ListenerRegistration domRegistration = domDataBroker.registerDataChangeListener(store, + domPath, domDataChangeListener, triggeringScope); return new ListenerRegistrationImpl(listener, domRegistration); } - protected Map, DataObject> fromDOMToData( - 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 { - Entry, DataObject> binding = getCodec().toBinding(entry); - newMap.put(binding.getKey(), binding.getValue()); - } catch (DeserializationException e) { - LOG.debug("Ommiting {}",entry,e); + final Optional, DataObject>> potential = getCodec().toBinding(entry); + if (potential.isPresent()) { + final Entry, DataObject> binding = potential.get(); + newMap.put(binding.getKey(), binding.getValue()); + } + } catch (final DeserializationException e) { + LOG.warn("Failed to transform {}, omitting it", entry, e); } } return newMap; } + protected Set> toBinding(final InstanceIdentifier path, + final Set normalized) { + final Set> hashSet = new HashSet<>(); + for (final YangInstanceIdentifier normalizedPath : normalized) { + try { + final Optional> potential = getCodec().toBinding(normalizedPath); + if (potential.isPresent()) { + final InstanceIdentifier binding = potential.get(); + hashSet.add(binding); + } else if (normalizedPath.getLastPathArgument() instanceof YangInstanceIdentifier.AugmentationIdentifier) { + hashSet.add(path); + } + } catch (final DeserializationException e) { + LOG.warn("Failed to transform {}, omitting it", normalizedPath, e); + } + } + return hashSet; + } + + protected Optional toBindingData(final InstanceIdentifier path, final NormalizedNode data) { + if (path.isWildcarded()) { + return Optional.absent(); + } + return (Optional) 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; @@ -115,23 +138,43 @@ public abstract class AbstractForwardedDataBroker implements Delegator> change) { - bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change,path)); + public void onDataChanged(final AsyncDataChangeEvent> change) { + bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change, path)); + } + + @Override + public String toString() { + return bindingDataChangeListener.getClass().getName(); } } - private class TranslatedDataChangeEvent implements AsyncDataChangeEvent, DataObject> { - private final AsyncDataChangeEvent> domEvent; - private InstanceIdentifier path; + /** + * Translator for ClusteredDataChangeListener + */ - public TranslatedDataChangeEvent( - final AsyncDataChangeEvent> change) { - this.domEvent = change; + 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 InstanceIdentifier path; + + private Map, DataObject> createdCache; + private Map, DataObject> updatedCache; + 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; @@ -139,59 +182,77 @@ public abstract class AbstractForwardedDataBroker implements Delegator, DataObject> getCreatedData() { - return fromDOMToData(domEvent.getCreatedData()); + if (createdCache == null) { + createdCache = Collections.unmodifiableMap(toBinding(path, domEvent.getCreatedData())); + } + return createdCache; } @Override public Map, DataObject> getUpdatedData() { - return fromDOMToData(domEvent.getUpdatedData()); + if (updatedCache == null) { + updatedCache = Collections.unmodifiableMap(toBinding(path, domEvent.getUpdatedData())); + } + return updatedCache; } @Override public Set> getRemovedPaths() { - final Set removedPaths = domEvent - .getRemovedPaths(); - final Set> output = new HashSet<>(); - for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier instanceIdentifier : removedPaths) { - try { - output.add(mappingService.fromDataDom(instanceIdentifier)); - } catch (DeserializationException e) { - Exceptions.sneakyThrow(e); - } + if (removedCache == null) { + removedCache = Collections.unmodifiableSet(toBinding(path, domEvent.getRemovedPaths())); } - - return output; + return removedCache; } @Override - public Map, ? extends DataObject> getOriginalData() { - return fromDOMToData(domEvent.getOriginalData()); + public Map, DataObject> getOriginalData() { + if (originalCache == null) { + originalCache = Collections.unmodifiableMap(toBinding(path, domEvent.getOriginalData())); + } + return originalCache; } @Override public DataObject getOriginalSubtree() { - - return toBindingData(path,domEvent.getOriginalSubtree()); + if (originalDataCache == null) { + if (domEvent.getOriginalSubtree() != null) { + originalDataCache = toBindingData(path, domEvent.getOriginalSubtree()); + } else { + originalDataCache = Optional.absent(); + } + } + return originalDataCache.orNull(); } @Override public DataObject getUpdatedSubtree() { - - return toBindingData(path,domEvent.getUpdatedSubtree()); + if (updatedDataCache == null) { + if (domEvent.getUpdatedSubtree() != null) { + updatedDataCache = toBindingData(path, domEvent.getUpdatedSubtree()); + } else { + updatedDataCache = Optional.absent(); + } + } + return updatedDataCache.orNull(); } @Override public String toString() { - return "TranslatedDataChangeEvent [domEvent=" + domEvent + "]"; + return MoreObjects.toStringHelper(TranslatedDataChangeEvent.class) // + .add("created", getCreatedData()) // + .add("updated", getUpdatedData()) // + .add("removed", getRemovedPaths()) // + .add("dom", domEvent) // + .toString(); } } - private static class ListenerRegistrationImpl extends AbstractListenerRegistration { + 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; @@ -203,41 +264,8 @@ public abstract class AbstractForwardedDataBroker implements Delegator path, final NormalizedNode data) { - try { - return getCodec().toBinding(path, data); - } catch (DeserializationException e) { - return null; - } - } - - - @Override - public BindingIndependentConnector getConnector() { - return this.connector; - } - - @Override - public ProviderSession getDomProviderContext() { - return this.context; - } - - @Override - public void setConnector(final BindingIndependentConnector connector) { - this.connector = connector; - } - - @Override - public void setDomProviderContext(final ProviderSession domProviderContext) { - this.context = domProviderContext; - } - @Override - public void startForwarding() { - // NOOP + public void close() { } - - - }