--- /dev/null
+/**
+ * Copyright (c) 2015 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.md.sal.dom.spi;
+
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+
+/**
+ * An abstract tree of registrations. Allows a read-only snapshot to be taken.
+ *
+ * @param <T> Type of registered object
+ */
+public abstract class AbstractRegistrationTree<T> {
+ private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
+ private final RegistrationTreeNode<T> rootNode = new RegistrationTreeNode<>(null, null);
+
+ protected AbstractRegistrationTree() {
+
+ }
+
+ /**
+ * Acquire the read-write lock. This should be done before invoking {@link #findNodeFor(Iterable)}.
+ */
+ protected final void takeLock() {
+ rwLock.writeLock().lock();
+ }
+
+ /**
+ * Release the read-write lock. This should be done after invocation of {@link #findNodeFor(Iterable)}
+ * and modification of the returned node. Note that callers should do so in a finally block.
+ */
+ protected final void releaseLock() {
+ rwLock.writeLock().unlock();
+ }
+
+ /**
+ * Find an existing, or allocate a fresh, node for a particular path. Must be called with the
+ * read-write lock held.
+ *
+ * @param path Path to find a node for
+ * @return A registration node for the specified path
+ */
+ @Nonnull protected final RegistrationTreeNode<T> findNodeFor(@Nonnull final Iterable<PathArgument> path) {
+ RegistrationTreeNode<T> walkNode = rootNode;
+ for (final PathArgument arg : path) {
+ walkNode = walkNode.ensureChild(arg);
+ }
+
+ return walkNode;
+ }
+
+ /**
+ * Add a registration to a particular node. The node must have been returned via {@link #findNodeFor(Iterable)}
+ * and the lock must still be held.
+ *
+ * @param node Tree node
+ * @param registration Registration instance
+ */
+ protected final void addRegistration(@Nonnull final RegistrationTreeNode<T> node, @Nonnull final T registration) {
+ node.addRegistration(registration);
+ }
+
+ /**
+ * Remove a registration from a particular node. This method must not be called while the read-write lock
+ * is held.
+ *
+ * @param node Tree node
+ * @param registration Registration instance
+ */
+ protected final void removeRegistration(@Nonnull final RegistrationTreeNode<T> node, @Nonnull final T registration) {
+ // Take the write lock
+ rwLock.writeLock().lock();
+ try {
+ node.removeRegistration(registration);
+ } finally {
+ // Always release the lock
+ rwLock.writeLock().unlock();
+ }
+ }
+
+ /**
+ * Obtain a tree snapshot. This snapshot ensures a consistent view of
+ * registrations. The snapshot should be closed as soon as it is not required,
+ * because each unclosed instance blocks modification of this tree.
+ *
+ * @return A snapshot instance.
+ */
+ @Nonnull public final RegistrationTreeSnapshot<T> takeSnapshot() {
+ final RegistrationTreeSnapshot<T> ret = new RegistrationTreeSnapshot<>(rwLock.readLock(), rootNode);
+ rwLock.readLock().lock();
+ return ret;
+ }
+}
--- /dev/null
+/**
+ * Copyright (c) 2015 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.md.sal.dom.spi;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This is a single node within the registration tree. Note that the data returned from
+ * and instance of this class is guaranteed to have any relevance or consistency
+ * only as long as the {@link RegistrationTreeSnapshot} instance through which it is reached
+ * remains unclosed.
+ *
+ * @param <T> registration type
+ * @author Robert Varga
+ */
+public final class RegistrationTreeNode<T> implements Identifiable<PathArgument> {
+ private static final Logger LOG = LoggerFactory.getLogger(RegistrationTreeNode.class);
+
+ private final Map<PathArgument, RegistrationTreeNode<T>> children = new HashMap<>();
+ private final Collection<T> registrations = new ArrayList<>(2);
+ private final Collection<T> publicRegistrations = Collections.unmodifiableCollection(registrations);
+ private final Reference<RegistrationTreeNode<T>> parent;
+ private final PathArgument identifier;
+
+ RegistrationTreeNode(final RegistrationTreeNode<T> parent, final PathArgument identifier) {
+ this.parent = new WeakReference<>(parent);
+ this.identifier = identifier;
+ }
+
+ @Override
+ public PathArgument getIdentifier() {
+ return identifier;
+ }
+
+ /**
+ * Return the child matching a {@link PathArgument} specification.
+ *
+ * @param arg Child identifier
+ * @return Child matching exactly, or null.
+ */
+ public RegistrationTreeNode<T> getExactChild(@Nonnull final PathArgument arg) {
+ return children.get(Preconditions.checkNotNull(arg));
+ }
+
+ /**
+ * Return a collection children which match a {@link PathArgument} specification inexactly.
+ * This explicitly excludes the child returned by {@link #getExactChild(PathArgument)}.
+ *
+ * @param arg Child identifier
+ * @return Collection of children, guaranteed to be non-null.
+ */
+ public @Nonnull Collection<RegistrationTreeNode<T>> getInexactChildren(@Nonnull final PathArgument arg) {
+ Preconditions.checkNotNull(arg);
+ if (arg instanceof NodeWithValue || arg instanceof NodeIdentifierWithPredicates) {
+ /*
+ * TODO: This just all-or-nothing wildcards, which we have historically supported. Given
+ * that the argument is supposed to have all the elements filled out, we could support
+ * partial wildcards by iterating over the registrations and matching the maps for
+ * partial matches.
+ */
+ final RegistrationTreeNode<T> child = children.get(new NodeIdentifier(arg.getNodeType()));
+ if (child == null) {
+ return Collections.emptyList();
+ } else {
+ return Collections.singletonList(child);
+ }
+ } else {
+ return Collections.emptyList();
+ }
+ }
+
+ public Collection<T> getRegistrations() {
+ return publicRegistrations;
+ }
+
+ RegistrationTreeNode<T> ensureChild(@Nonnull final PathArgument child) {
+ RegistrationTreeNode<T> potential = children.get(Preconditions.checkNotNull(child));
+ if (potential == null) {
+ potential = new RegistrationTreeNode<T>(this, child);
+ children.put(child, potential);
+ }
+ return potential;
+ }
+
+ void addRegistration(@Nonnull final T registration) {
+ registrations.add(Preconditions.checkNotNull(registration));
+ LOG.debug("Registration {} added", registration);
+ }
+
+ void removeRegistration(@Nonnull final T registration) {
+ registrations.remove(Preconditions.checkNotNull(registration));
+ LOG.debug("Registration {} removed", registration);
+
+ // We have been called with the write-lock held, so we can perform some cleanup.
+ removeThisIfUnused();
+ }
+
+ private void removeThisIfUnused() {
+ final RegistrationTreeNode<T> p = parent.get();
+ if (p != null && registrations.isEmpty() && children.isEmpty()) {
+ p.removeChild(identifier);
+ }
+ }
+
+ private void removeChild(final PathArgument arg) {
+ children.remove(arg);
+ removeThisIfUnused();
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this)
+ .add("identifier", identifier)
+ .add("registrations", registrations.size())
+ .add("children", children.size()).toString();
+ }
+}
--- /dev/null
+/**
+ * Copyright (c) 2015 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.md.sal.dom.spi;
+
+import com.google.common.base.Preconditions;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.locks.Lock;
+
+/**
+ * A stable read-only snapshot of a {@link AbstractRegistrationTree}.
+ *
+ * @author Robert Varga
+ */
+public final class RegistrationTreeSnapshot<T> implements AutoCloseable {
+ @SuppressWarnings("rawtypes")
+ private static final AtomicIntegerFieldUpdater<RegistrationTreeSnapshot> CLOSED_UPDATER = AtomicIntegerFieldUpdater.newUpdater(RegistrationTreeSnapshot.class, "closed");
+ private final RegistrationTreeNode<T> node;
+ private final Lock lock;
+
+ // Used via CLOSED_UPDATER
+ @SuppressWarnings("unused")
+ private volatile int closed = 0;
+
+ RegistrationTreeSnapshot(final Lock lock, final RegistrationTreeNode<T> node) {
+ this.lock = Preconditions.checkNotNull(lock);
+ this.node = Preconditions.checkNotNull(node);
+ }
+
+ public RegistrationTreeNode<T> getRootNode() {
+ return node;
+ }
+
+ @Override
+ public void close() {
+ if (CLOSED_UPDATER.compareAndSet(this, 0, 1)) {
+ lock.unlock();
+ }
+ }
+}
--- /dev/null
+/**
+ * Copyright (c) 2015 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.md.sal.dom.store.impl.tree;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
+import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
+import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+abstract class DataChangeListenerRegistrationImpl<T extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> extends AbstractListenerRegistration<T> implements DataChangeListenerRegistration<T> {
+ public DataChangeListenerRegistrationImpl(final T listener) {
+ super(listener);
+ }
+}
\ No newline at end of file
package org.opendaylight.controller.md.sal.dom.store.impl.tree;
import com.google.common.base.Optional;
-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
+import com.google.common.base.Preconditions;
import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
+import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.DataChangeListenerRegistrationImpl;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* This is a single node within the listener tree. Note that the data returned from
* @author Robert Varga
*/
public class ListenerNode implements StoreTreeNode<ListenerNode>, Identifiable<PathArgument> {
+ final RegistrationTreeNode<DataChangeListenerRegistration<?>> delegate;
- private static final Logger LOG = LoggerFactory.getLogger(ListenerNode.class);
-
- private final Collection<DataChangeListenerRegistration<?>> listeners = new ArrayList<>();
- private final Map<PathArgument, ListenerNode> children = new HashMap<>();
- private final PathArgument identifier;
- private final Reference<ListenerNode> parent;
-
- ListenerNode(final ListenerNode parent, final PathArgument identifier) {
- this.parent = new WeakReference<>(parent);
- this.identifier = identifier;
+ ListenerNode(final RegistrationTreeNode<DataChangeListenerRegistration<?>> delegate) {
+ this.delegate = Preconditions.checkNotNull(delegate);
}
@Override
public PathArgument getIdentifier() {
- return identifier;
+ return delegate.getIdentifier();
}
@Override
public Optional<ListenerNode> getChild(final PathArgument child) {
- return Optional.fromNullable(children.get(child));
+ final RegistrationTreeNode<DataChangeListenerRegistration<?>> c = delegate.getExactChild(child);
+ if (c == null) {
+ return Optional.absent();
+ }
+
+ return Optional.of(new ListenerNode(c));
}
/**
* @return the list of current listeners
*/
public Collection<DataChangeListenerRegistration<?>> getListeners() {
- return listeners;
+ return delegate.getRegistrations();
}
- ListenerNode ensureChild(final PathArgument child) {
- ListenerNode potential = children.get(child);
- if (potential == null) {
- potential = new ListenerNode(this, child);
- children.put(child, potential);
- }
- return potential;
- }
-
- void addListener(final DataChangeListenerRegistration<?> listener) {
- listeners.add(listener);
- LOG.debug("Listener {} registered", listener);
- }
-
- void removeListener(final DataChangeListenerRegistrationImpl<?> listener) {
- listeners.remove(listener);
- LOG.debug("Listener {} unregistered", listener);
-
- // We have been called with the write-lock held, so we can perform some cleanup.
- removeThisIfUnused();
- }
-
- private void removeThisIfUnused() {
- final ListenerNode p = parent.get();
- if (p != null && listeners.isEmpty() && children.isEmpty()) {
- p.removeChild(identifier);
- }
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
}
- private void removeChild(final PathArgument arg) {
- children.remove(arg);
- removeThisIfUnused();
+ @Override
+ public boolean equals(final Object obj) {
+ return delegate.equals(obj);
}
@Override
public String toString() {
- return "Node [identifier=" + identifier + ", listeners=" + listeners.size() + ", children=" + children.size() + "]";
+ return delegate.toString();
}
}
*/
package org.opendaylight.controller.md.sal.dom.store.impl.tree;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
+import org.opendaylight.controller.md.sal.dom.spi.AbstractRegistrationTree;
+import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
-import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* A set of listeners organized as a tree by node to which they listen. This class
*
* @author Robert Varga
*/
-public final class ListenerTree {
- private static final Logger LOG = LoggerFactory.getLogger(ListenerTree.class);
- private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
- private final ListenerNode rootNode = new ListenerNode(null, null);
-
+public final class ListenerTree extends AbstractRegistrationTree<DataChangeListenerRegistration<?>> {
private ListenerTree() {
// Private to disallow direct instantiation
}
final L listener, final DataChangeScope scope) {
// Take the write lock
- rwLock.writeLock().lock();
-
+ takeLock();
try {
- ListenerNode walkNode = rootNode;
- for (final PathArgument arg : path.getPathArguments()) {
- walkNode = walkNode.ensureChild(arg);
- }
-
- final ListenerNode node = walkNode;
+ final RegistrationTreeNode<DataChangeListenerRegistration<?>> node = findNodeFor(path.getPathArguments());
DataChangeListenerRegistration<L> reg = new DataChangeListenerRegistrationImpl<L>(listener) {
@Override
public DataChangeScope getScope() {
* While this does not directly violate the ListenerRegistration
* contract, it is probably not going to be liked by the users.
*/
-
- // Take the write lock
- ListenerTree.this.rwLock.writeLock().lock();
- try {
- node.removeListener(this);
- } finally {
- // Always release the lock
- ListenerTree.this.rwLock.writeLock().unlock();
- }
+ ListenerTree.this.removeRegistration(node, this);
}
};
- node.addListener(reg);
+ addRegistration(node, reg);
return reg;
} finally {
// Always release the lock
- rwLock.writeLock().unlock();
+ releaseLock();
}
}
* external user exist, make the Walker a phantom reference, which
* will cleanup the lock if not told to do so.
*/
- final ListenerWalker ret = new ListenerWalker(rwLock.readLock(), rootNode);
- rwLock.readLock().lock();
- return ret;
- }
-
- abstract static class DataChangeListenerRegistrationImpl<T extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> extends AbstractListenerRegistration<T> //
- implements DataChangeListenerRegistration<T> {
- public DataChangeListenerRegistrationImpl(final T listener) {
- super(listener);
- }
+ return new ListenerWalker(takeSnapshot());
}
}
package org.opendaylight.controller.md.sal.dom.store.impl.tree;
import com.google.common.base.Preconditions;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import java.util.concurrent.locks.Lock;
+import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeSnapshot;
+import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
/**
* A walking context, pretty much equivalent to an iterator, but it
* @author Robert Varga
*/
public class ListenerWalker implements AutoCloseable {
- private static final AtomicIntegerFieldUpdater<ListenerWalker> CLOSED_UPDATER = AtomicIntegerFieldUpdater.newUpdater(ListenerWalker.class, "closed");
- private final Lock lock;
- private final ListenerNode node;
+ private final RegistrationTreeSnapshot<DataChangeListenerRegistration<?>> delegate;
- // Used via CLOSED_UPDATER
- @SuppressWarnings("unused")
- private volatile int closed = 0;
-
- ListenerWalker(final Lock lock, final ListenerNode node) {
- this.lock = Preconditions.checkNotNull(lock);
- this.node = Preconditions.checkNotNull(node);
+ ListenerWalker(final RegistrationTreeSnapshot<DataChangeListenerRegistration<?>> delegate) {
+ this.delegate = Preconditions.checkNotNull(delegate);
}
public ListenerNode getRootNode() {
- return node;
+ return new ListenerNode(delegate.getRootNode());
}
@Override
public void close() {
- if (CLOSED_UPDATER.compareAndSet(this, 0, 1)) {
- lock.unlock();
- }
+ delegate.close();
}
}
\ No newline at end of file
Code Review / controller.git / commitdiff