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=c34c737e9532d4d1d99b989072e36084c1e375c1;hp=e632e6336aaf959808a28f9ecc209432c504b4eb;hb=466078ab1dc8a8cc2981b161051f6edecd6af85a;hpb=46751de4454b9a6f5cf73db39f90f0189ceae986 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 e632e6336a..c34c737e95 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,72 +7,44 @@ */ 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; import java.util.HashMap; import java.util.HashSet; -import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; +import java.util.Optional; 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; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; 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.yangtools.concepts.AbstractListenerRegistration; +import org.opendaylight.mdsal.dom.api.DOMSchemaService; 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, 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.registerSchemaContextListener(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 @@ -80,93 +52,40 @@ public abstract class AbstractForwardedDataBroker implements Delegator registerDataChangeListener(final LogicalDatastoreType store, - final InstanceIdentifier path, final DataChangeListener listener, - final DataChangeScope triggeringScope) { - DOMDataChangeListener domDataChangeListener = new TranslatingDataChangeInvoker(store, path, listener, - triggeringScope); - YangInstanceIdentifier domPath = codec.toNormalized(path); - ListenerRegistration domRegistration = domDataBroker.registerDataChangeListener(store, - domPath, domDataChangeListener, triggeringScope); - return new ListenerRegistrationImpl(listener, domRegistration); - } - - protected Map, DataObject> toBinding( - InstanceIdentifier path, + protected Map, DataObject> toBinding(final InstanceIdentifier path, final Map> normalized) { - Map, DataObject> newMap = new HashMap<>(); + final Map, DataObject> newMap = new HashMap<>(); - for (Map.Entry> entry : sortedEntries(normalized)) { + 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()); - } 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) { + } catch (final DeserializationException e) { LOG.warn("Failed to transform {}, omitting it", entry, e); } } return newMap; } - private static final Comparator> MAP_ENTRY_COMPARATOR = new Comparator>() { - @Override - public int compare(final Entry left, - final Entry right) { - final Iterator li = left.getKey().getPathArguments().iterator(); - final Iterator ri = right.getKey().getPathArguments().iterator(); - - // Iterate until left is exhausted... - while (li.hasNext()) { - if (!ri.hasNext()) { - // Left is deeper - return 1; - } - - li.next(); - ri.next(); - } - - // Check if right is exhausted - return ri.hasNext() ? -1 : 0; - } - }; - - private static Iterable> sortedEntries(final Map map) { - if (!map.isEmpty()) { - ArrayList> entries = new ArrayList<>(map.entrySet()); - Collections.sort(entries, MAP_ENTRY_COMPARATOR); - return entries; - } else { - return Collections.emptySet(); - } - } - - protected Set> toBinding(InstanceIdentifier path, + protected Set> toBinding(final InstanceIdentifier path, final Set normalized) { - Set> hashSet = new HashSet<>(); - for (YangInstanceIdentifier normalizedPath : 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) { + } 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); } } @@ -175,167 +94,13 @@ public abstract class AbstractForwardedDataBroker implements Delegator toBindingData(final InstanceIdentifier path, final NormalizedNode data) { if (path.isWildcarded()) { - return Optional.absent(); - } - - try { - return Optional.fromNullable(getCodec().toBinding(path, data)); - } catch (DeserializationException e) { - return Optional.absent(); - } - } - - private class TranslatingDataChangeInvoker implements DOMDataChangeListener { - 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 DataChangeListener bindingDataChangeListener, final DataChangeScope triggeringScope) { - this.store = store; - this.path = path; - this.bindingDataChangeListener = bindingDataChangeListener; - this.triggeringScope = triggeringScope; - } - - @Override - public void onDataChanged( - final AsyncDataChangeEvent> change) { - bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change, path)); - } - } - - 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 InstanceIdentifier path) { - this.domEvent = change; - this.path = path; - } - - @Override - public Map, DataObject> getCreatedData() { - if (createdCache == null) { - createdCache = Collections.unmodifiableMap(toBinding(path, domEvent.getCreatedData())); - } - return createdCache; - } - - @Override - public Map, DataObject> getUpdatedData() { - if (updatedCache == null) { - updatedCache = Collections.unmodifiableMap(toBinding(path, domEvent.getUpdatedData())); - } - return updatedCache; - - } - - @Override - public Set> getRemovedPaths() { - if (removedCache == null) { - removedCache = Collections.unmodifiableSet(toBinding(path, domEvent.getRemovedPaths())); - } - return removedCache; - } - - @Override - public Map, DataObject> getOriginalData() { - if (originalCache == null) { - originalCache = Collections.unmodifiableMap(toBinding(path, domEvent.getOriginalData())); - } - return originalCache; - - } - - @Override - public DataObject getOriginalSubtree() { - if (originalDataCache == null) { - if(domEvent.getOriginalSubtree() != null) { - originalDataCache = toBindingData(path, domEvent.getOriginalSubtree()); - } else { - originalDataCache = Optional.absent(); - } - } - return originalDataCache.orNull(); - } - - @Override - public DataObject 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 Objects.toStringHelper(TranslatedDataChangeEvent.class) // - .add("created", getCreatedData()) // - .add("updated", getUpdatedData()) // - .add("removed", getRemovedPaths()) // - .add("dom", domEvent) // - .toString(); + return Optional.empty(); } - } - - private static class ListenerRegistrationImpl extends AbstractListenerRegistration { - private final ListenerRegistration registration; - - public ListenerRegistrationImpl(final DataChangeListener listener, - final ListenerRegistration registration) { - super(listener); - this.registration = registration; - } - - @Override - protected void removeRegistration() { - registration.close(); - } - } - - @Override - public BindingIndependentConnector getConnector() { - return this.connector; - } - - @Override - public ProviderSession getDomProviderContext() { - return this.context; + return (Optional) getCodec().deserializeFunction(path) + .apply(Optional.>of(data)); } @Override - public void setConnector(final BindingIndependentConnector connector) { - this.connector = connector; + public void close() { } - - @Override - public void setDomProviderContext(final ProviderSession domProviderContext) { - this.context = domProviderContext; - } - - @Override - public void startForwarding() { - // NOOP - } - - @Override - public void close() throws Exception { - this.schemaListenerRegistration.close(); - } - }