[dna-commits] DNA SVN: r1081 - in trunk/dna-graph/src: main/java/org/jboss/dna/graph/property and 4 other directories.
dna-commits at lists.jboss.org
dna-commits at lists.jboss.org
Thu Jul 9 12:23:09 EDT 2009
Author: rhauch
Date: 2009-07-09 12:23:09 -0400 (Thu, 09 Jul 2009)
New Revision: 1081
Added:
trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/
trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/GraphSession.java
trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/InvalidStateException.java
trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/ValidationException.java
trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/
trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/GraphCacheTest.java
Modified:
trunk/dna-graph/src/main/java/org/jboss/dna/graph/Graph.java
trunk/dna-graph/src/main/java/org/jboss/dna/graph/GraphI18n.java
trunk/dna-graph/src/main/java/org/jboss/dna/graph/Node.java
trunk/dna-graph/src/main/java/org/jboss/dna/graph/property/PathNotFoundException.java
trunk/dna-graph/src/main/resources/org/jboss/dna/graph/GraphI18n.properties
Log:
DNA-466 Added new session-based system to the Graph API.
Modified: trunk/dna-graph/src/main/java/org/jboss/dna/graph/Graph.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/Graph.java 2009-07-09 16:22:06 UTC (rev 1080)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/Graph.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -41,6 +41,7 @@
import java.util.Map;
import java.util.Set;
import java.util.UUID;
+import java.util.concurrent.TimeUnit;
import net.jcip.annotations.Immutable;
import net.jcip.annotations.NotThreadSafe;
import org.jboss.dna.common.collection.EmptyIterator;
@@ -63,6 +64,7 @@
import org.jboss.dna.graph.property.ValueFormatException;
import org.jboss.dna.graph.property.Path.Segment;
import org.jboss.dna.graph.request.BatchRequestBuilder;
+import org.jboss.dna.graph.request.CacheableRequest;
import org.jboss.dna.graph.request.CloneWorkspaceRequest;
import org.jboss.dna.graph.request.CompositeRequest;
import org.jboss.dna.graph.request.CreateNodeRequest;
@@ -1819,13 +1821,15 @@
}
public List<Location> under( Location at ) {
- return requests.readBlockOfChildren(at, getCurrentWorkspaceName(), startingIndex, blockSize).getChildren();
+ return requests.readBlockOfChildren(at, getCurrentWorkspaceName(), startingIndex, blockSize)
+ .getChildren();
}
};
}
public List<Location> startingAfter( final Location previousSibling ) {
- return requests.readNextBlockOfChildren(previousSibling, getCurrentWorkspaceName(), blockSize).getChildren();
+ return requests.readNextBlockOfChildren(previousSibling, getCurrentWorkspaceName(), blockSize)
+ .getChildren();
}
public List<Location> startingAfter( String pathOfPreviousSibling ) {
@@ -3726,7 +3730,7 @@
assertNotExecuted();
return new At<BatchConjunction>() {
public BatchConjunction at( Location location ) {
- requestQueue.readBranch(location, getCurrentWorkspaceName());
+ requestQueue.readBranch(location, getCurrentWorkspaceName(), depth);
return Batch.this.nextRequests;
}
@@ -3833,6 +3837,11 @@
return value;
}
+ protected static DateTime computeExpirationTime( CacheableRequest request ) {
+ CachePolicy policy = request.getCachePolicy();
+ return policy == null ? null : request.getTimeLoaded().plus(policy.getTimeToLive(), TimeUnit.MILLISECONDS);
+ }
+
/**
* The interface used to specify the name of a new workspace.
*/
@@ -5363,6 +5372,11 @@
return request.getActualLocationOfNode();
}
+ public DateTime getExpirationTime() {
+ CachePolicy policy = request.getCachePolicy();
+ return policy == null ? null : request.getTimeLoaded().plus(policy.getTimeToLive(), TimeUnit.MILLISECONDS);
+ }
+
public Graph getGraph() {
return Graph.this;
}
@@ -5431,24 +5445,29 @@
for (Request request : requests) {
if (request instanceof ReadAllPropertiesRequest) {
ReadAllPropertiesRequest read = (ReadAllPropertiesRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).setProperties(read.getPropertiesByName());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).setProperties(read.getPropertiesByName());
} else if (request instanceof ReadPropertyRequest) {
ReadPropertyRequest read = (ReadPropertyRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).addProperty(read.getProperty());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).addProperty(read.getProperty());
} else if (request instanceof ReadNodeRequest) {
ReadNodeRequest read = (ReadNodeRequest)request;
- BatchResultsNode node = getOrCreateNode(read.getActualLocationOfNode());
+ DateTime expires = computeExpirationTime(read);
+ BatchResultsNode node = getOrCreateNode(read.getActualLocationOfNode(), expires);
node.setProperties(read.getPropertiesByName());
node.setChildren(read.getChildren());
} else if (request instanceof ReadBlockOfChildrenRequest) {
throw new IllegalStateException();
} else if (request instanceof ReadAllChildrenRequest) {
ReadAllChildrenRequest read = (ReadAllChildrenRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).setChildren(read.getChildren());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).setChildren(read.getChildren());
} else if (request instanceof ReadBranchRequest) {
ReadBranchRequest read = (ReadBranchRequest)request;
+ DateTime expires = computeExpirationTime(read);
for (Location location : read) {
- BatchResultsNode node = getOrCreateNode(location);
+ BatchResultsNode node = getOrCreateNode(location, expires);
node.setProperties(read.getPropertiesFor(location));
node.setChildren(read.getChildren(location));
}
@@ -5462,24 +5481,29 @@
/*package*/BatchResults( Request request ) {
if (request instanceof ReadAllPropertiesRequest) {
ReadAllPropertiesRequest read = (ReadAllPropertiesRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).setProperties(read.getPropertiesByName());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).setProperties(read.getPropertiesByName());
} else if (request instanceof ReadPropertyRequest) {
ReadPropertyRequest read = (ReadPropertyRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).addProperty(read.getProperty());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).addProperty(read.getProperty());
} else if (request instanceof ReadNodeRequest) {
ReadNodeRequest read = (ReadNodeRequest)request;
- BatchResultsNode node = getOrCreateNode(read.getActualLocationOfNode());
+ DateTime expires = computeExpirationTime(read);
+ BatchResultsNode node = getOrCreateNode(read.getActualLocationOfNode(), expires);
node.setProperties(read.getPropertiesByName());
node.setChildren(read.getChildren());
} else if (request instanceof ReadBlockOfChildrenRequest) {
throw new IllegalStateException();
} else if (request instanceof ReadAllChildrenRequest) {
ReadAllChildrenRequest read = (ReadAllChildrenRequest)request;
- getOrCreateNode(read.getActualLocationOfNode()).setChildren(read.getChildren());
+ DateTime expires = computeExpirationTime(read);
+ getOrCreateNode(read.getActualLocationOfNode(), expires).setChildren(read.getChildren());
} else if (request instanceof ReadBranchRequest) {
ReadBranchRequest read = (ReadBranchRequest)request;
+ DateTime expires = computeExpirationTime(read);
for (Location location : read) {
- BatchResultsNode node = getOrCreateNode(location);
+ BatchResultsNode node = getOrCreateNode(location, expires);
node.setProperties(read.getPropertiesFor(location));
node.setChildren(read.getChildren(location));
}
@@ -5492,10 +5516,11 @@
/*package*/BatchResults() {
}
- private BatchResultsNode getOrCreateNode( Location location ) {
+ private BatchResultsNode getOrCreateNode( Location location,
+ DateTime expirationTime ) {
BatchResultsNode node = nodes.get(location);
if (node == null) {
- node = new BatchResultsNode(location);
+ node = new BatchResultsNode(location, expirationTime);
assert location.getPath() != null;
nodes.put(location.getPath(), node);
}
@@ -5566,13 +5591,20 @@
@Immutable
class BatchResultsNode implements Node {
private final Location location;
+ private final DateTime expirationTime;
private Map<Name, Property> properties;
private List<Location> children;
- BatchResultsNode( Location location ) {
+ BatchResultsNode( Location location,
+ DateTime expirationTime ) {
this.location = location;
+ this.expirationTime = expirationTime;
}
+ public DateTime getExpirationTime() {
+ return expirationTime;
+ }
+
void addProperty( Property property ) {
if (this.properties == null) this.properties = new HashMap<Name, Property>();
this.properties.put(property.getName(), property);
@@ -5739,7 +5771,10 @@
}
public SubgraphNode getNode( Name relativePath ) {
- Path path = getGraph().getContext().getValueFactories().getPathFactory().create(getLocation().getPath(), relativePath);
+ Path path = getGraph().getContext()
+ .getValueFactories()
+ .getPathFactory()
+ .create(getLocation().getPath(), relativePath);
path = path.getNormalizedPath();
return getNode(path);
}
@@ -5777,6 +5812,10 @@
this.request = request;
}
+ public DateTime getExpirationTime() {
+ return computeExpirationTime(request);
+ }
+
public List<Location> getChildren() {
List<Location> children = request.getChildren(location);
if (children == null) children = NO_CHILDREN;
Modified: trunk/dna-graph/src/main/java/org/jboss/dna/graph/GraphI18n.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/GraphI18n.java 2009-07-09 16:22:06 UTC (rev 1080)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/GraphI18n.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -121,6 +121,11 @@
public static I18n moveLimitedToBeWithinSingleSource;
public static I18n cloneLimitedToBeWithinSingleSource;
+ /* Session */
+ public static I18n unableToRefreshBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch;
+ public static I18n unableToSaveBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch;
+ public static I18n nodeHasAlreadyBeenRemovedFromThisSession;
+
static {
try {
I18n.initialize(GraphI18n.class);
Modified: trunk/dna-graph/src/main/java/org/jboss/dna/graph/Node.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/Node.java 2009-07-09 16:22:06 UTC (rev 1080)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/Node.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -27,6 +27,7 @@
import java.util.List;
import java.util.Map;
import net.jcip.annotations.Immutable;
+import org.jboss.dna.graph.property.DateTime;
import org.jboss.dna.graph.property.Name;
import org.jboss.dna.graph.property.Path;
import org.jboss.dna.graph.property.Property;
@@ -47,6 +48,13 @@
Graph getGraph();
/**
+ * Get the time at which this node representation should no longer be used.
+ *
+ * @return the expiration time, or null if there is none
+ */
+ DateTime getExpirationTime();
+
+ /**
* Get the location of the node.
*
* @return the node's location
Modified: trunk/dna-graph/src/main/java/org/jboss/dna/graph/property/PathNotFoundException.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/property/PathNotFoundException.java 2009-07-09 16:22:06 UTC (rev 1080)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/property/PathNotFoundException.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -105,8 +105,8 @@
@Override
public String getMessage() {
if (this.lowestAncestorThatDoesExist != null) {
- return GraphI18n.pathNotFoundExceptionLowestExistingLocationFound.text(super.getMessage(),
- this.lowestAncestorThatDoesExist);
+ String locationPart = location.hasPath() ? location.getPath().toString() : location.toString();
+ return GraphI18n.pathNotFoundExceptionLowestExistingLocationFound.text(locationPart, this.lowestAncestorThatDoesExist);
}
return super.getMessage();
}
Added: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/GraphSession.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/GraphSession.java (rev 0)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/GraphSession.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -0,0 +1,2562 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.graph.session;
+
+import java.security.AccessControlException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import net.jcip.annotations.Immutable;
+import net.jcip.annotations.NotThreadSafe;
+import net.jcip.annotations.ThreadSafe;
+import org.jboss.dna.common.collection.ReadOnlyIterator;
+import org.jboss.dna.common.i18n.I18n;
+import org.jboss.dna.common.util.CheckArg;
+import org.jboss.dna.common.util.HashCode;
+import org.jboss.dna.common.util.StringUtil;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Graph;
+import org.jboss.dna.graph.GraphI18n;
+import org.jboss.dna.graph.Location;
+import org.jboss.dna.graph.Results;
+import org.jboss.dna.graph.Subgraph;
+import org.jboss.dna.graph.connector.RepositorySourceException;
+import org.jboss.dna.graph.connector.UuidAlreadyExistsException;
+import org.jboss.dna.graph.property.DateTime;
+import org.jboss.dna.graph.property.Name;
+import org.jboss.dna.graph.property.NamespaceRegistry;
+import org.jboss.dna.graph.property.Path;
+import org.jboss.dna.graph.property.PathFactory;
+import org.jboss.dna.graph.property.PathNotFoundException;
+import org.jboss.dna.graph.property.Property;
+import org.jboss.dna.graph.request.BatchRequestBuilder;
+import org.jboss.dna.graph.request.ChangeRequest;
+import org.jboss.dna.graph.request.CreateNodeRequest;
+import org.jboss.dna.graph.request.InvalidWorkspaceException;
+import org.jboss.dna.graph.request.Request;
+import org.jboss.dna.graph.session.GraphSession.Authorizer.Action;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimaps;
+
+/**
+ * This class represents an interactive session for working with the content within a graph. This session maintains a cache of
+ * content read from the repository, as well as transient changes that have been made to the nodes within this session that are
+ * then pushed to the graph when the session is {@link #save() saved}.
+ * <p>
+ * Like the other Graph APIs, the mutable objects in this session should not be held onto for very long periods of time. When the
+ * session is {@link #save() saved} or {{@link #refresh(boolean) refreshed} (or when a node is {@link #save(Node) saved} or
+ * {@link #refresh(Node, boolean) refreshed}), the session may {@link Node#unload() unload} and discard some of its nodes. Using
+ * nodes after they are discarded may result in assertion errors (assuming Java assertions are enabled).
+ * </p>
+ *
+ * @param <Payload> the type of the payload object for each node, used to allow the nodes to hold additional cached information
+ * @param <PropertyPayload> the type of payload object for each property, used to allow the nodes to hold additional cached
+ * information
+ */
+ at NotThreadSafe
+public class GraphSession<Payload, PropertyPayload> {
+
+ protected final ListMultimap<Name, Node<Payload, PropertyPayload>> NO_CHILDREN = Multimaps.immutableMultimap();
+ protected final Map<Name, PropertyInfo<PropertyPayload>> NO_PROPERTIES = Collections.emptyMap();
+
+ protected final Authorizer authorizer;
+ protected final ExecutionContext context;
+ protected final Graph store;
+ protected final Node<Payload, PropertyPayload> root;
+ protected final Operations<Payload, PropertyPayload> nodeOperations;
+ protected final PathFactory pathFactory;
+ protected final NodeIdFactory idFactory;
+ protected final String workspaceName;
+ protected int loadDepth = 1;
+
+ /**
+ * A map of the nodes keyed by their identifier.
+ */
+ protected final Map<NodeId, Node<Payload, PropertyPayload>> nodes = new HashMap<NodeId, Node<Payload, PropertyPayload>>();
+ /**
+ * A map that records how the changes to a node are dependent upon other nodes.
+ */
+ protected final Map<NodeId, Dependencies> changeDependencies = new HashMap<NodeId, Dependencies>();
+
+ private LinkedList<Request> requests;
+ private BatchRequestBuilder requestBuilder;
+ protected Graph.Batch operations;
+
+ /**
+ * Create a session that uses the supplied graph and the supplied node operations.
+ *
+ * @param graph the graph that this session is to use
+ * @param workspaceName the name of the workspace that is to be used, or null if the current workspace should be used
+ * @param nodeOperations the operations that are to be performed during various stages in the lifecycle of a node, or null if
+ * there are no special operations that should be performed
+ */
+ public GraphSession( Graph graph,
+ String workspaceName,
+ Operations<Payload, PropertyPayload> nodeOperations ) {
+ this(graph, workspaceName, nodeOperations, null);
+ }
+
+ /**
+ * Create a session that uses the supplied graph and the supplied node operations.
+ *
+ * @param graph the graph that this session is to use
+ * @param workspaceName the name of the workspace that is to be used, or null if the current workspace should be used
+ * @param nodeOperations the operations that are to be performed during various stages in the lifecycle of a node, or null if
+ * there are no special operations that should be performed
+ * @param authorizer the authorizing component, or null if no special authorization is to be performed
+ * @throws IllegalArgumentException if the graph reference is null
+ * @throws IllegalArgumentException if the depth is not positive
+ */
+ public GraphSession( Graph graph,
+ String workspaceName,
+ Operations<Payload, PropertyPayload> nodeOperations,
+ Authorizer authorizer ) {
+ assert graph != null;
+ this.store = graph;
+ this.context = store.getContext();
+ if (workspaceName != null) {
+ this.workspaceName = this.store.useWorkspace(workspaceName).getName();
+ } else {
+ this.workspaceName = this.store.getCurrentWorkspaceName();
+ }
+ this.nodeOperations = nodeOperations != null ? nodeOperations : new SimpleNodeOperations<Payload, PropertyPayload>();
+ this.pathFactory = context.getValueFactories().getPathFactory();
+ this.authorizer = authorizer != null ? authorizer : new NoOpAuthorizer();
+ // Create the NodeId factory ...
+ this.idFactory = new NodeIdFactory() {
+ private long nextId = 0L;
+
+ public NodeId create() {
+ return new NodeId(++nextId);
+ }
+ };
+ // Create the root node ...
+ Location rootLocation = Location.create(pathFactory.createRootPath());
+ NodeId rootId = idFactory.create();
+ this.root = createNode(null, rootId, rootLocation);
+ this.nodes.put(rootId, root);
+
+ // Create the batch operations ...
+ this.requests = new LinkedList<Request>();
+ this.requestBuilder = new BatchRequestBuilder(this.requests);
+ this.operations = this.store.batch(this.requestBuilder);
+ }
+
+ /**
+ * Get the subgraph depth that is read when a node is loaded from the persistence store. By default, this value is 1.
+ *
+ * @return the loading depth; always positive
+ */
+ public int getDepthForLoadingNodes() {
+ return loadDepth;
+ }
+
+ /**
+ * Set the loading depth parameter, which controls how deep a subgraph should be read when a node is loaded from the
+ * persistence store. By default, this value is 1.
+ *
+ * @param depth the depth that should be read whenever a single node is loaded
+ * @throws IllegalArgumentException if the depth is not positive
+ */
+ public void setDepthForLoadingNodes( int depth ) {
+ CheckArg.isPositive(depth, "depth");
+ this.loadDepth = depth;
+ }
+
+ /**
+ * Get the root node.
+ *
+ * @return the root node; never null
+ */
+ public Node<Payload, PropertyPayload> getRoot() {
+ return root;
+ }
+
+ /**
+ * Get the path factory that should be used to adjust the path objects.
+ *
+ * @return the path factory; never null
+ */
+ public PathFactory getPathFactory() {
+ return pathFactory;
+ }
+
+ /**
+ * Find in the session the node with the supplied identifier.
+ *
+ * @param id the identifier of the node
+ * @return the identified node, or null if the session has no node with the supplied identifier
+ * @throws IllegalArgumentException if the identifier is null
+ */
+ public Node<Payload, PropertyPayload> findNodeWith( NodeId id ) {
+ CheckArg.isNotNull(id, "id");
+ return nodes.get(id);
+ }
+
+ /**
+ * Find the node with the supplied identifier or, if no such node is found, the node at the supplied path. Note that if a node
+ * was found by the identifier, the resulting may not have the same path as that supplied as a parameter.
+ *
+ * @param id the identifier to the node; may be null if the node is to be found by path
+ * @param path the path that should be used to find the node only when the cache doesn't contain a node with the identifier
+ * @return the node with the supplied id and/or path
+ * @throws IllegalArgumentException if the identifier and path are both node
+ * @throws PathNotFoundException if the node at the supplied path does not exist
+ * @throws AccessControlException if the user does not have permission to read the nodes given by the supplied path
+ */
+ public Node<Payload, PropertyPayload> findNodeWith( NodeId id,
+ Path path ) throws PathNotFoundException, AccessControlException {
+ if (id == null && path == null) {
+ CheckArg.isNotNull(path, "path and id");
+ }
+ Node<Payload, PropertyPayload> result = nodes.get(id); // if found, the user should have read privilege since it was
+ // already in the cache
+ if (result == null && path != null) {
+ result = findNodeWith(path);
+ }
+ return result;
+ }
+
+ /**
+ * Find the node with the supplied path. This node quickly finds the node if it exists in the cache, or if it is not in the
+ * cache, it loads the nodes down the supplied path.
+ *
+ * @param path the path to the node
+ * @return the node information
+ * @throws PathNotFoundException if the node at the supplied path does not exist
+ * @throws AccessControlException if the user does not have permission to read the nodes given by the supplied path
+ */
+ public Node<Payload, PropertyPayload> findNodeWith( Path path ) throws PathNotFoundException, AccessControlException {
+ if (path.isRoot()) return getRoot();
+ return findNodeRelativeTo(root, path.relativeTo(root.getPath()));
+ }
+
+ /**
+ * Find the node with the supplied path relative to another node. This node quickly finds the node by walking the supplied
+ * relative path starting at the supplied node. As soon as a cached node is found to not be fully loaded, the persistent
+ * information for that node and all remaining nodes along the relative path are read from the persistent store and inserted
+ * into the cache.
+ *
+ * @param startingPoint the node from which the path is relative
+ * @param relativePath the relative path from the designated starting point to the desired node; may not be null and may not
+ * be an {@link Path#isAbsolute() absolute} path
+ * @return the node information
+ * @throws PathNotFoundException if the node at the supplied path does not exist
+ * @throws AccessControlException if the user does not have permission to read the nodes given by the supplied path
+ */
+ @SuppressWarnings( "synthetic-access" )
+ public Node<Payload, PropertyPayload> findNodeRelativeTo( Node<Payload, PropertyPayload> startingPoint,
+ Path relativePath )
+ throws PathNotFoundException, AccessControlException {
+ Node<Payload, PropertyPayload> node = startingPoint;
+ if (!relativePath.isRoot()) {
+ // Find the absolute path, which ensures that the relative path is well-formed ...
+ Path absolutePath = relativePath.resolveAgainst(startingPoint.getPath());
+
+ // Verify that the user has the appropriate privileges to read these nodes...
+ authorizer.checkPermissions(absolutePath, Action.READ);
+
+ // Walk down the path ...
+ Iterator<Path.Segment> iter = relativePath.iterator();
+ while (iter.hasNext()) {
+ Path.Segment segment = iter.next();
+ try {
+ if (segment.isSelfReference()) continue;
+ if (segment.isParentReference()) {
+ node = node.getParent();
+ assert node != null; // since the relative path is well-formed
+ continue;
+ }
+
+ if (node.isLoaded()) {
+ // The child is the next node we need to process ...
+ node = node.getChild(segment);
+ } else {
+ // The node has not yet been loaded into the cache, so read this node
+ // from the store as well as all nodes along the path to the node we're really
+ // interested in. We'll do this in a batch, so first create this batch ...
+ Graph.Batch batch = store.batch();
+
+ // Figure out which nodes along the path need to be loaded from the store ...
+ Path firstPath = node.getPath();
+ batch.read(firstPath);
+ // Now add the path to the child (which is no longer on the iterator) ...
+ Path nextPath = pathFactory.create(firstPath, segment);
+ if (!iter.hasNext() && loadDepth > 1) {
+ batch.readSubgraphOfDepth(loadDepth).at(nextPath);
+ } else {
+ batch.read(nextPath);
+ }
+ // Now add any remaining paths that are still on the iterator ...
+ while (iter.hasNext()) {
+ nextPath = pathFactory.create(nextPath, iter.next());
+ if (!iter.hasNext() && loadDepth > 1) {
+ batch.readSubgraphOfDepth(loadDepth).at(nextPath);
+ } else {
+ batch.read(nextPath);
+ }
+ }
+
+ // Load all of the nodes (we should be reading at least 2 nodes) ...
+ Results batchResults = batch.execute();
+
+ // Add the children and properties in the lowest cached node ...
+ Path previousPath = null;
+ Node<Payload, PropertyPayload> topNode = node;
+ Node<Payload, PropertyPayload> previousNode = node;
+ for (org.jboss.dna.graph.Node persistentNode : batchResults) {
+ Location location = persistentNode.getLocation();
+ Path path = location.getPath();
+ if (path.isRoot()) {
+ previousNode = root;
+ root.location = location;
+ } else {
+ if (path.getParent().equals(previousPath)) {
+ previousNode = previousNode.getChild(path.getLastSegment());
+ } else {
+ Path subgraphPath = path.relativeTo(topNode.getPath());
+ previousNode = findNodeRelativeTo(topNode, subgraphPath);
+ }
+ // Set the node that we're looking for ...
+ if (path.getLastSegment().equals(relativePath.getLastSegment()) && path.equals(absolutePath)) {
+ node = previousNode;
+ }
+ }
+ nodeOperations.update(persistentNode, previousNode);
+ previousPath = path;
+ }
+ }
+ } catch (PathNotFoundException e) {
+ // Use the correct desired path ...
+ throw new PathNotFoundException(Location.create(relativePath), e.getLowestAncestorThatDoesExist());
+ }
+ }
+ }
+ return node;
+ }
+
+ /**
+ * Returns whether the session cache has any pending changes that need to be executed.
+ *
+ * @return true if there are pending changes, or false if there is currently no changes
+ */
+ public boolean hasPendingChanges() {
+ return root.isChanged(true);
+ }
+
+ /**
+ * Remove any cached information that has been marked as a transient change.
+ */
+ public void clearAllChangedNodes() {
+ root.clearChanges();
+ changeDependencies.clear();
+ requests.clear();
+ }
+
+ /**
+ * Move this node from its current location so that is is a child of the supplied parent, but do so immediately without
+ * enqueuing the operation within the session's operations.
+ *
+ * @param nodeToMove the node that is to be moved; may not be null
+ * @param newParent the new parent for this node; may not be null
+ * @param newName the new name for the node, or null if the node is not to be renamed
+ * @throws RepositorySourceException if the parent node is to be loaded but a problem is encountered while doing so
+ * @throws IllegalArgumentException if the node being moved is the root node
+ */
+ public void immediateMove( Node<Payload, PropertyPayload> nodeToMove,
+ Node<Payload, PropertyPayload> newParent,
+ Name newName ) {
+ CheckArg.isNotNull(nodeToMove, "nodeToMove");
+ CheckArg.isNotNull(newParent, "newParent");
+ nodeToMove.moveTo(newParent, newName, false);
+ }
+
+ /**
+ * Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the
+ * current workspace, doing so immediately without enqueuing the operation within the session's operations. The current
+ * session is modified immediately to reflect the copy result.
+ * <p>
+ * Note that the destination path should not include a same-name-sibling index, since this will be ignored and will always be
+ * recomputed (as the copy will be appended to any children already in the destination's parent).
+ * </p>
+ *
+ * @param source the path to the node that is to be copied; may not be null
+ * @param destination the path where the copy is to be placed; may not be null index
+ * @throws IllegalArgumentException either path is null or invalid
+ */
+ public void immediateCopy( Path source,
+ Path destination ) {
+ immediateCopy(source, workspaceName, destination);
+ }
+
+ /**
+ * Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the
+ * current workspace, doing so immediately without enqueuing the operation within the session's operations. The current
+ * session is modified immediately to reflect the copy result.
+ * <p>
+ * Note that the destination path should not include a same-name-sibling index, since this will be ignored and will always be
+ * recomputed (as the copy will be appended to any children already in the destination's parent).
+ * </p>
+ *
+ * @param source the path to the node that is to be copied; may not be null
+ * @param sourceWorkspace the name of the workspace where the source node is to be found, or null if the current workspace
+ * should be used
+ * @param destination the path where the copy is to be placed; may not be null index
+ * @throws IllegalArgumentException either path is null or invalid
+ * @throws InvalidWorkspaceException if the source workspace name is invalid or does not exist
+ */
+ public void immediateCopy( Path source,
+ String sourceWorkspace,
+ Path destination ) {
+ CheckArg.isNotNull(source, "source");
+ CheckArg.isNotNull(destination, "destination");
+ if (sourceWorkspace == null) sourceWorkspace = workspaceName;
+
+ // Perform the copy operation, but use the "to" form (not the "into", which takes the parent), but
+ // but use a batch so that we can read the latest list of children ...
+ Results results = store.batch()
+ .copy(source)
+ .fromWorkspace(sourceWorkspace)
+ .to(destination)
+ .and()
+ .readChildren()
+ .of(destination.getParent())
+ .execute();
+
+ // Now get the children of the destination's parent ...
+ Location parentLocation = results.getNode(destination).getLocation();
+ // Find the parent node in the session ...
+ Node<Payload, PropertyPayload> parent = this.findNodeWith(parentLocation.getPath());
+ if (parent.isLoaded()) {
+ // Update the children to make them match the latest snapshot from the store ...
+ List<Location> newChildren = results.getNode(parentLocation).getChildren();
+ parent.synchronize(newChildren);
+ }
+ }
+
+ /**
+ * Clone the supplied source branch and place into the destination location, optionally removing any existing copy that
+ * already exists in the destination location.
+ *
+ * @param source
+ * @param sourceWorkspace
+ * @param destination
+ * @param removeExisting true if the original should be removed, or false if the original should be left
+ * @throws UuidAlreadyExistsException if copy could not be completed because the current workspace already includes at least
+ * one of the nodes at or below the <code>source</code> branch in the source workspace
+ */
+ public void immediateClone( Path source,
+ String sourceWorkspace,
+ Path destination,
+ boolean removeExisting ) {
+
+ // Perform the copy operation, but use the "to" form (not the "into", which takes the parent), but
+ // but use a batch so that we can read the latest list of children ...
+ Graph.Batch batch = store.batch();
+ if (removeExisting) {
+ // Perform the copy operation, but use the "to" form (not the "into", which takes the parent) ...
+ batch.copy(source).replacingExistingNodesWithSameUuids().fromWorkspace(sourceWorkspace).to(destination);
+ } else {
+ // Perform the copy operation, but use the "to" form (not the "into", which takes the parent) ...
+ batch.copy(source).failingIfUuidsMatch().fromWorkspace(sourceWorkspace).to(destination);
+ }
+ // And read the children of the destination's parent ...
+ batch.readChildren().of(destination.getParent());
+ // Now execute these two operations ...
+ Results results = batch.execute();
+
+ // Now get the children of the destination's parent ...
+ Location parentLocation = results.getNode(destination).getLocation();
+ // Find the parent node in the session ...
+ Node<Payload, PropertyPayload> parent = this.findNodeWith(parentLocation.getPath());
+ if (parent.isLoaded()) {
+ // Update the children to make them match the latest snapshot from the store ...
+ List<Location> newChildren = results.getNode(parentLocation).getChildren();
+ parent.synchronize(newChildren);
+ }
+ }
+
+ /**
+ * Refreshes (removes the cached state) for all cached nodes.
+ * <p>
+ * If {@code keepChanges == true}, modified nodes will not have their state refreshed, while all others will either be
+ * unloaded or changed to reflect the current state of the persistent store.
+ * </p>
+ *
+ * @param keepChanges indicates whether changed nodes should be kept or refreshed from the repository.
+ * @throws InvalidStateException if any error resulting while reading information from the repository
+ * @throws RepositorySourceException if any error resulting while reading information from the repository
+ */
+ @SuppressWarnings( "synthetic-access" )
+ public void refresh( boolean keepChanges ) throws InvalidStateException, RepositorySourceException {
+ if (keepChanges) {
+ refresh(root, keepChanges);
+ } else {
+ // Clear out all state ...
+ nodes.clear();
+ nodes.put(root.getNodeId(), root);
+ // Clear out all changes ...
+ requests.clear();
+ changeDependencies.clear();
+ // And force the root node to be 'unloaded' (in an efficient way) ...
+ root.changed = false;
+ root.childrenByName = null;
+ root.expirationTime = Long.MAX_VALUE;
+ }
+ }
+
+ /**
+ * Refreshes (removes the cached state) for the given node and its descendants.
+ * <p>
+ * If {@code keepChanges == true}, modified nodes will not have their state refreshed, while all others will either be
+ * unloaded or changed to reflect the current state of the persistent store.
+ * </p>
+ *
+ * @param node the node that is to be refreshed; may not be null
+ * @param keepChanges indicates whether changed nodes should be kept or refreshed from the repository.
+ * @throws InvalidStateException if any error resulting while reading information from the repository
+ * @throws RepositorySourceException if any error resulting while reading information from the repository
+ */
+ public void refresh( Node<Payload, PropertyPayload> node,
+ boolean keepChanges ) throws InvalidStateException, RepositorySourceException {
+ if (!node.isRoot() && node.isChanged(true)) {
+ // Need to make sure that changes to this branch are not dependent upon changes to nodes outside of this branch...
+ if (!node.containsChangesWithExternalDependencies()) {
+ I18n msg = GraphI18n.unableToRefreshBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch;
+ String path = node.getPath().getString(context.getNamespaceRegistry());
+ throw new InvalidStateException(msg.text(path, workspaceName));
+ }
+ }
+
+ if (keepChanges && node.isChanged(true)) {
+ // Perform the refresh while retaining changes ...
+ // Phase 1: determine which nodes can be unloaded, which must be refreshed, and which must be unchanged ...
+ RefreshState<Payload, PropertyPayload> refreshState = new RefreshState<Payload, PropertyPayload>();
+ node.refreshPhase1(refreshState);
+ // If there are any nodes to be refreshed, read then in a single batch ...
+ Results readResults = null;
+ if (!refreshState.getNodesToBeRefreshed().isEmpty()) {
+ Graph.Batch batch = store.batch();
+ for (Node<Payload, PropertyPayload> nodeToBeRefreshed : refreshState.getNodesToBeRefreshed()) {
+ batch.read(nodeToBeRefreshed.getLocation());
+ }
+ // Execute the reads. No modifications have been made to the cache, so it is not a problem
+ // if this throws a repository exception.
+ readResults = batch.execute();
+ }
+
+ // Phase 2: update the cache by unloading or refreshing the nodes ...
+ node.refreshPhase2(refreshState, readResults);
+ } else {
+ // Get rid of all changes ...
+ node.clearChanges();
+ // And then unload the node ...
+ node.unload();
+
+ // Throw out the old pending operations
+ if (operations.isExecuteRequired()) {
+ // Make sure the builder has finished all the requests ...
+ this.requestBuilder.finishPendingRequest();
+
+ // Remove all of the enqueued requests for this branch ...
+ for (Iterator<Request> iter = this.requests.iterator(); iter.hasNext();) {
+ Request request = iter.next();
+ assert request instanceof ChangeRequest;
+ ChangeRequest change = (ChangeRequest)request;
+ if (change.changes(workspaceName, node.getPath())) {
+ iter.remove();
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Save any changes that have been accumulated by this session.
+ *
+ * @throws PathNotFoundException if the state of this session is invalid and is attempting to change a node that doesn't exist
+ * @throws ValidationException if any of the changes being made result in an invalid node state
+ * @throws InvalidStateException if the supplied node is no longer a node within this cache (because it was unloaded)
+ */
+ public void save() throws PathNotFoundException, ValidationException, InvalidStateException {
+ if (!operations.isExecuteRequired()) return;
+ assert root.isChanged(true);
+
+ // Make sure that each of the changed node is valid. This process requires that all children of
+ // all changed nodes are loaded, so in this process load all unloaded children in one batch ...
+ root.onChangedNodes(new LoadAllChildrenVisitor() {
+ @Override
+ protected void finishParentAfterLoading( Node<Payload, PropertyPayload> node ) {
+ nodeOperations.validate(node);
+ }
+ });
+
+ // Execute the batched operations ...
+ operations.execute();
+
+ // Create a new batch for future operations ...
+ // LinkedList<Request> oldRequests = this.requests;
+ this.requests = new LinkedList<Request>();
+ this.requestBuilder = new BatchRequestBuilder(this.requests);
+ operations = store.batch(this.requestBuilder);
+
+ // Remove all the cached items that have been changed or deleted ...
+ this.root.clearChanges();
+
+ // Remove all the changed and deleted infos ...
+ changeDependencies.clear();
+ }
+
+ /**
+ * Save any changes to the identified node or its descendants. The supplied node may not have been deleted or created in this
+ * session since the last save operation.
+ *
+ * @param node the node being saved; may not be null
+ * @throws PathNotFoundException if the state of this session is invalid and is attempting to change a node that doesn't exist
+ * @throws ValidationException if any of the changes being made result in an invalid node state
+ * @throws InvalidStateException if the supplied node is no longer a node within this cache (because it was unloaded)
+ */
+ public void save( Node<Payload, PropertyPayload> node )
+ throws PathNotFoundException, ValidationException, InvalidStateException {
+ assert node != null;
+ if (node.isRoot()) {
+ // We're actually saving the root, so the other 'save' method is faster and more efficient ...
+ save();
+ return;
+ }
+ if (node.isStale()) {
+ // This node was deleted in this session ...
+ String readableLocation = node.getLocation().getString(context.getNamespaceRegistry());
+ I18n msg = GraphI18n.nodeHasAlreadyBeenRemovedFromThisSession;
+ throw new InvalidStateException(msg.text(readableLocation, workspaceName));
+ }
+ if (!node.isChanged(true)) {
+ // There are no changes within this branch
+ return;
+ }
+
+ // Need to make sure that changes to this branch are not dependent upon changes to nodes outside of this branch...
+ if (!node.containsChangesWithExternalDependencies()) {
+ I18n msg = GraphI18n.unableToSaveBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch;
+ String path = node.getPath().getString(context.getNamespaceRegistry());
+ throw new InvalidStateException(msg.text(path, workspaceName));
+ }
+
+ // Make sure that each of the changed node is valid. This process requires that all children of
+ // all changed nodes are loaded, so in this process load all unloaded children in one batch ...
+ root.onChangedNodes(new LoadAllChildrenVisitor() {
+ @Override
+ protected void finishParentAfterLoading( Node<Payload, PropertyPayload> node ) {
+ nodeOperations.validate(node);
+ }
+ });
+
+ // Make sure the builder has finished all the requests ...
+ this.requestBuilder.finishPendingRequest();
+
+ // Remove all of the enqueued requests for this branch ...
+ Path path = node.getPath();
+ LinkedList<Request> branchRequests = new LinkedList<Request>();
+ LinkedList<Request> nonBranchRequests = new LinkedList<Request>();
+ Set<UUID> branchUuids = new HashSet<UUID>();
+ for (Request request : this.requests) {
+ assert request instanceof ChangeRequest;
+ ChangeRequest change = (ChangeRequest)request;
+ if (change.changes(workspaceName, path)) {
+ branchRequests.add(request);
+ // Record the UUID of the node being saved now ...
+ UUID changedUuid = null;
+ if (change instanceof CreateNodeRequest) {
+ // We want the parent UUID ...
+ changedUuid = ((CreateNodeRequest)change).under().getUuid();
+ } else {
+ changedUuid = change.changedLocation().getUuid();
+ }
+ assert changedUuid != null;
+ branchUuids.add(changedUuid);
+ } else {
+ nonBranchRequests.add(request);
+ }
+ }
+ if (branchRequests.isEmpty()) return;
+
+ // Now execute the branch ...
+ Graph.Batch branchBatch = store.batch(new BatchRequestBuilder(branchRequests));
+ branchBatch.execute();
+
+ // Still have non-branch related requests that we haven't executed ...
+ this.requests = nonBranchRequests;
+ this.requestBuilder = new BatchRequestBuilder(this.requests);
+ this.operations = store.batch(this.requestBuilder);
+
+ // Remove all the cached, changed or deleted items that were just saved ...
+ node.clearChanges();
+ }
+
+ protected Node<Payload, PropertyPayload> createNode( Node<Payload, PropertyPayload> parent,
+ NodeId nodeId,
+ Location location ) {
+ return new Node<Payload, PropertyPayload>(this, parent, nodeId, location);
+ }
+
+ protected long getCurrentTime() {
+ return System.currentTimeMillis();
+ }
+
+ protected void recordMove( Node<Payload, PropertyPayload> nodeBeingMoved,
+ Node<Payload, PropertyPayload> oldParent,
+ Node<Payload, PropertyPayload> newParent ) {
+ // Fix the cache's state ...
+ NodeId id = nodeBeingMoved.getNodeId();
+ Dependencies dependencies = changeDependencies.get(id);
+ if (dependencies == null) {
+ dependencies = new Dependencies();
+ dependencies.setMovedFrom(oldParent.getNodeId());
+ changeDependencies.put(id, dependencies);
+ } else {
+ dependencies.setMovedFrom(newParent.getNodeId());
+ }
+ }
+
+ /**
+ * Record the fact that the supplied node is in the process of being deleted, so any cached information (outside of the node
+ * object itself) should be cleaned up.
+ *
+ * @param node the node being deleted; never null
+ */
+ protected void recordDelete( Node<Payload, PropertyPayload> node ) {
+ // Record the operation ...
+ operations.delete(node.getLocation());
+ // Fix the cache's state ...
+ nodes.remove(node.getNodeId());
+ changeDependencies.remove(node.getNodeId());
+ recordUnloaded(node);
+ }
+
+ /**
+ * Record the fact that the supplied node is in the process of being unloaded, so any cached information (outside of the node
+ * object itself) should be cleaned up.
+ *
+ * @param node the node being unloaded; never null
+ */
+ protected void recordUnloaded( final Node<Payload, PropertyPayload> node ) {
+ if (node.isLoaded() && node.getChildrenCount() > 0) {
+ // Walk the branch and remove all nodes from the map of all nodes ...
+ node.onLoadedNodes(new NodeVisitor<Payload, PropertyPayload>() {
+ @SuppressWarnings( "synthetic-access" )
+ @Override
+ public boolean visit( Node<Payload, PropertyPayload> unloaded ) {
+ if (unloaded != node) { // info for 'node' should not be removed
+ nodes.remove(unloaded.getNodeId());
+ changeDependencies.remove(unloaded.getNodeId());
+ unloaded.parent = null;
+ }
+ return true;
+ }
+ });
+ }
+ }
+
+ @ThreadSafe
+ public static interface Operations<NodePayload, PropertyPayload> {
+
+ /**
+ * Update the node with the information from the persistent store.
+ *
+ * @param persistentNode the persistent node that should be converted into a node info; never null
+ * @param node the session's node representation that is to be updated; never null
+ */
+ void update( org.jboss.dna.graph.Node persistentNode,
+ Node<NodePayload, PropertyPayload> node );
+
+ /**
+ * Signal that the node's {@link GraphSession.Node#getLocation() location} has been changed
+ *
+ * @param node the node with the new location
+ * @param oldLocation the old location of the node
+ */
+ void updateLocation( Node<NodePayload, PropertyPayload> node,
+ Location oldLocation );
+
+ /**
+ * Validate a node for consistency and well-formedness.
+ *
+ * @param node the node to be validated
+ * @throws ValidationException if there is a problem during validation
+ */
+ void validate( Node<NodePayload, PropertyPayload> node ) throws ValidationException;
+ }
+
+ @ThreadSafe
+ public static interface NodeIdFactory {
+ NodeId create();
+ }
+
+ @ThreadSafe
+ public static interface Authorizer {
+
+ public enum Action {
+ READ,
+ REMOVE,
+ ADD_NODE,
+ SET_PROPERTY;
+ }
+
+ /**
+ * Throws an {@link AccessControlException} if the current user is not able to perform the action on the node at the
+ * supplied path in the current workspace.
+ *
+ * @param path the path on which the actions are occurring
+ * @param action the action to check
+ * @throws AccessControlException if the user does not have permission to perform the actions
+ */
+ void checkPermissions( Path path,
+ Action action ) throws AccessControlException;
+ }
+
+ /**
+ * {@link Authorizer} implementation that does nothing.
+ */
+ @ThreadSafe
+ protected static class NoOpAuthorizer implements Authorizer {
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.session.GraphSession.Authorizer#checkPermissions(org.jboss.dna.graph.property.Path,
+ * org.jboss.dna.graph.session.GraphSession.Authorizer.Action)
+ */
+ public void checkPermissions( Path path,
+ Action action ) throws AccessControlException {
+ }
+ }
+
+ @ThreadSafe
+ protected static class SimpleNodeOperations<Payload, PropertyPayload> implements Operations<Payload, PropertyPayload> {
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.Operations#update(org.jboss.dna.graph.Node, GraphSession.Node)
+ */
+ public void update( org.jboss.dna.graph.Node persistentNode,
+ Node<Payload, PropertyPayload> node ) {
+ // Create the map of property info objects ...
+ Map<Name, PropertyInfo<PropertyPayload>> properties = new HashMap<Name, PropertyInfo<PropertyPayload>>();
+ for (Property property : persistentNode.getProperties()) {
+ Name propertyName = property.getName();
+ PropertyId id = new PropertyId(node.getNodeId(), propertyName);
+ PropertyInfo<PropertyPayload> info = new PropertyInfo<PropertyPayload>(id, property, property.isMultiple(),
+ PropertyStatus.UNCHANGED, null);
+ properties.put(propertyName, info);
+ }
+ // Set only the children ...
+ node.loadedWith(persistentNode.getChildren(), properties, persistentNode.getExpirationTime());
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.Operations#updateLocation(GraphSession.Node, org.jboss.dna.graph.Location)
+ */
+ public void updateLocation( Node<Payload, PropertyPayload> node,
+ Location oldLocation ) {
+ // do nothing here
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.Operations#validate(GraphSession.Node)
+ */
+ public void validate( Node<Payload, PropertyPayload> node ) {
+ // do nothing here
+ }
+ }
+
+ @NotThreadSafe
+ public static class Node<Payload, PropertyPayload> {
+ private final GraphSession<Payload, PropertyPayload> cache;
+ private final NodeId nodeId;
+ private Node<Payload, PropertyPayload> parent;
+ private long expirationTime = Long.MAX_VALUE;
+ private Location location;
+ private boolean changed;
+ private boolean changedBelow;
+ private Map<Name, PropertyInfo<PropertyPayload>> properties;
+ private ListMultimap<Name, Node<Payload, PropertyPayload>> childrenByName;
+ private Payload payload;
+
+ protected Node( GraphSession<Payload, PropertyPayload> cache,
+ Node<Payload, PropertyPayload> parent,
+ NodeId nodeId,
+ Location location ) {
+ this.cache = cache;
+ this.parent = parent;
+ this.nodeId = nodeId;
+ this.location = location;
+ assert this.cache != null;
+ assert this.nodeId != null;
+ assert this.location != null;
+ assert this.location.hasPath();
+ }
+
+ /**
+ * Get the time when this node expires.
+ *
+ * @return the time in milliseconds past the epoch when this node's cached information expires, or {@link Long#MAX_VALUE
+ * Long.MAX_VALUE} if there is no expiration or if the node has not been loaded
+ * @see #isExpired()
+ * @see #isLoaded()
+ */
+ public final long getExpirationTimeInMillis() {
+ assert !isStale();
+ return expirationTime;
+ }
+
+ /**
+ * Determine if this node's information has expired. This method will never return true if the node is not loaded. This
+ * method is idempotent.
+ *
+ * @return true if this node's information has been read from the store and is expired
+ */
+ public final boolean isExpired() {
+ return expirationTime != Long.MAX_VALUE && expirationTime < cache.getCurrentTime();
+ }
+
+ /**
+ * Determine if this node is loaded and usable. Even though the node may have been loaded previously, this method may
+ * return false (and unloads the cached information) if the cached information has expired and thus is no longer usable.
+ * Note, however, that changes on or below this node will prevent the node from being unloaded.
+ *
+ * @return true if the node's information has already been loaded and may be used, or false otherwise
+ */
+ public final boolean isLoaded() {
+ if (childrenByName == null) return false;
+ // Otherwise, it is already loaded. First see if this is expired ...
+ if (isExpired()) {
+ // It is expired, so we'd normally return false. But we should not unload if it has changes ...
+ if (isChanged(true)) return true;
+ // It is expired and contains no changes on this branch, so we can unload it ...
+ unload();
+ return false;
+ }
+ // Otherwise it is loaded and not expired ...
+ return true;
+ }
+
+ /**
+ * Method that causes the information for this node to be read from the store and loaded into the cache
+ *
+ * @throws RepositorySourceException if there is a problem reading the store
+ */
+ protected final void load() throws RepositorySourceException {
+ if (isLoaded()) return;
+ assert !isStale();
+ // Check authorization before reading ...
+ Path path = getPath();
+ cache.authorizer.checkPermissions(path, Action.READ);
+ int depth = cache.getDepthForLoadingNodes();
+ if (depth == 1) {
+ // Then read the node from the store ...
+ org.jboss.dna.graph.Node persistentNode = cache.store.getNodeAt(getLocation());
+ // Check the actual location ...
+ Location actualLocation = persistentNode.getLocation();
+ if (!this.location.equals(actualLocation)) {
+ // The actual location is changed, so update it ...
+ this.location = actualLocation;
+ }
+ // Update the persistent information ...
+ cache.nodeOperations.update(persistentNode, this);
+ } else {
+ // Then read the node from the store ...
+ Subgraph subgraph = cache.store.getSubgraphOfDepth(depth).at(getLocation());
+ Location actualLocation = subgraph.getLocation();
+ if (!this.location.equals(actualLocation)) {
+ // The actual location is changed, so update it ...
+ this.location = actualLocation;
+ }
+ // Update the persistent information ...
+ cache.nodeOperations.update(subgraph.getRoot(), this);
+ // Now update any nodes below this node ...
+ for (org.jboss.dna.graph.Node persistentNode : subgraph) {
+ // Find the node at the path ...
+ Path relativePath = persistentNode.getLocation().getPath().relativeTo(path);
+ Node<Payload, PropertyPayload> node = cache.findNodeRelativeTo(this, relativePath);
+ if (!node.isLoaded()) {
+ // Update the persistent information ...
+ cache.nodeOperations.update(persistentNode, node);
+ }
+ }
+ }
+ }
+
+ /**
+ * Utility method to unload this cached node.
+ */
+ protected final void unload() {
+ assert !isStale();
+ assert !changed;
+ assert !changedBelow;
+ if (!isLoaded()) return;
+ cache.recordUnloaded(this);
+ childrenByName = null;
+ expirationTime = Long.MAX_VALUE;
+ }
+
+ /**
+ * Phase 1 of the process of refreshing the cached content while retaining changes. This phase walks the entire tree to
+ * determine which nodes have changes, which nodes can be unloaded, and which nodes have no changes but are ancestors of
+ * those nodes with changes (and therefore have to be refreshed). Each node has a {@link #isChanged(boolean) changed
+ * state}, and the supplied RefreshState tracks which nodes must be
+ * {@link GraphSession.RefreshState#markAsRequiringRefresh(Node) refreshed} in
+ * {@link #refreshPhase2(RefreshState, Results) phase 2}; all other nodes are able to be unloaded in
+ * {@link #refreshPhase2(RefreshState, Results) phase 2}.
+ *
+ * @param refreshState the holder of the information about which nodes are to be unloaded or refreshed; may not be null
+ * @return true if the node could be (or already is) unloaded, or false otherwise
+ * @see #refreshPhase2(RefreshState, Results)
+ */
+ protected final boolean refreshPhase1( RefreshState<Payload, PropertyPayload> refreshState ) {
+ assert !isStale();
+ if (childrenByName == null) {
+ // This node is not yet loaded, so don't record it as needing to be unloaded but return true
+ return true;
+ }
+ // Perform phase 1 on each of the children ...
+ boolean canUnloadChildren = true;
+ for (Node<Payload, PropertyPayload> child : childrenByName.values()) {
+ if (child.refreshPhase1(refreshState)) {
+ // The child can be unloaded
+ canUnloadChildren = false;
+ }
+ }
+
+ // If this node has changes, then we cannot do anything with this node ...
+ if (isChanged(false)) return false;
+
+ // Otherwise, this node contains no changes ...
+ if (canUnloadChildren) {
+ // Since all the children can be unloaded, we can completely unload this node ...
+ return true;
+ }
+ // Otherwise, we have to hold onto the children, so we can't unload and must be refreshed ...
+ refreshState.markAsRequiringRefresh(this);
+ return false;
+ }
+
+ /**
+ * Phase 2 of the process of refreshing the cached content while retaining changes. This phase walks the graph and either
+ * unloads the node or, if the node is an ancestor of changed nodes, refreshes the node state to reflect that of the
+ * persistent store.
+ *
+ * @param refreshState
+ * @param persistentInfoForRefreshedNodes
+ * @see #refreshPhase1(RefreshState)
+ */
+ protected final void refreshPhase2( RefreshState<Payload, PropertyPayload> refreshState,
+ Results persistentInfoForRefreshedNodes ) {
+ assert !isStale();
+ if (this.changed) {
+ // There's nothing to do ...
+ return;
+ }
+ if (refreshState.requiresRefresh(this)) {
+ // This node must be refreshed since it has no changes but is an ancestor of a node that is changed.
+ // Therefore, update the children and properties with the just-read persistent information ...
+ assert childrenByName != null;
+ org.jboss.dna.graph.Node persistentNode = persistentInfoForRefreshedNodes.getNode(location);
+ assert !persistentNode.getChildren().isEmpty();
+ // Find the map of old Node objects keyed by their identifier ...
+ Map<NodeId, Node<Payload, PropertyPayload>> oldChildren = new HashMap<NodeId, Node<Payload, PropertyPayload>>();
+ for (Node<Payload, PropertyPayload> oldChild : childrenByName.values()) {
+ oldChildren.put(oldChild.getNodeId(), oldChild);
+ }
+ childrenByName.clear();
+ for (Location location : persistentNode.getChildren()) {
+ Name childName = location.getPath().getLastSegment().getName();
+ NodeId nodeId = cache.idFactory.create();
+ Node<Payload, PropertyPayload> child = oldChildren.remove(nodeId);
+ if (child == null) {
+ child = cache.createNode(this, nodeId, location);
+ cache.nodes.put(child.getNodeId(), child);
+ assert child.getName().equals(childName);
+ }
+ assert child.parent == this;
+ List<Node<Payload, PropertyPayload>> currentChildren = childrenByName.get(childName);
+ currentChildren.add(child);
+ // Create a segment with the SNS ...
+ Path.Segment segment = cache.pathFactory.createSegment(childName, currentChildren.size());
+ child.updateLocation(segment);
+ // TODO: Can the location be different? If so, doesn't that mean that the change requests
+ // have to be updated???
+ }
+ return;
+ }
+ // This node can be unloaded (since it has no changes and isn't above a node with changes) ...
+ unload();
+ }
+
+ /**
+ * Define the persistent child information that this node is to be populated with. This method does not cause the node's
+ * information to be read from the store.
+ * <p>
+ * This method is intended to be called by the {@link GraphSession.Operations#update(org.jboss.dna.graph.Node, Node)}, and
+ * should not be called by other components.
+ * </p>
+ *
+ * @param children the children for this node; may not be null
+ * @param properties the properties for this node; may not be null
+ * @param expirationTime the time that this cached information expires, or null if there is no expiration
+ */
+ public void loadedWith( List<Location> children,
+ Map<Name, PropertyInfo<PropertyPayload>> properties,
+ DateTime expirationTime ) {
+ assert !isStale();
+ // Load the children ...
+ if (children.isEmpty()) {
+ childrenByName = cache.NO_CHILDREN;
+ } else {
+ childrenByName = Multimaps.newLinkedListMultimap();
+ for (Location location : children) {
+ NodeId id = cache.idFactory.create();
+ Name childName = location.getPath().getLastSegment().getName();
+ Node<Payload, PropertyPayload> child = cache.createNode(this, id, location);
+ cache.nodes.put(child.getNodeId(), child);
+ List<Node<Payload, PropertyPayload>> currentChildren = childrenByName.get(childName);
+ currentChildren.add(child);
+ child.parent = this;
+ // Create a segment with the SNS ...
+ Path.Segment segment = cache.pathFactory.createSegment(childName, currentChildren.size());
+ child.updateLocation(segment);
+ }
+ }
+ // Load the properties ...
+ if (properties.isEmpty()) {
+ this.properties = cache.NO_PROPERTIES;
+ } else {
+ this.properties = new HashMap<Name, PropertyInfo<PropertyPayload>>(properties);
+ }
+
+ // Set the expiration time ...
+ this.expirationTime = expirationTime != null ? expirationTime.getMilliseconds() : Long.MAX_VALUE;
+ }
+
+ /**
+ * Reconstruct the location object for this node, given the information at the parent.
+ *
+ * @param segment the path segment for this node; may be null only when this node is the root node
+ */
+ protected void updateLocation( Path.Segment segment ) {
+ assert !isStale();
+ Path newPath = null;
+ if (segment != null) {
+ // Recompute the path based upon the parent path ...
+ Path parentPath = getParent().getPath();
+ newPath = cache.pathFactory.create(parentPath, segment);
+ } else {
+ // This must be the root ...
+ newPath = cache.pathFactory.createRootPath();
+ assert this.isRoot();
+ }
+ Location newLocation = this.location.with(newPath);
+ if (newLocation != this.location) {
+ Location oldLocation = this.location;
+ this.location = newLocation;
+ cache.nodeOperations.updateLocation(this, oldLocation);
+ }
+
+ if (isLoaded() && childrenByName != cache.NO_CHILDREN) {
+ // Update all of the children ...
+ for (Map.Entry<Name, Collection<Node<Payload, PropertyPayload>>> entry : childrenByName.asMap().entrySet()) {
+ Name childName = entry.getKey();
+ int sns = 1;
+ for (Node<Payload, PropertyPayload> child : entry.getValue()) {
+ Path.Segment childSegment = cache.pathFactory.createSegment(childName, sns++);
+ child.updateLocation(childSegment);
+ }
+ }
+ }
+ }
+
+ protected void synchronize( List<Location> actualChildren ) {
+ if (!isLoaded()) return;
+ for (Location actualChild : actualChildren) {
+ Path.Segment actualSegment = actualChild.getPath().getLastSegment();
+ Node<Payload, PropertyPayload> existingChild = parent.getChild(actualSegment);
+ if (existingChild == null) {
+ // The child doesn't exist yet ...
+ NodeId nodeId = cache.idFactory.create();
+ Node<Payload, PropertyPayload> newChild = cache.createNode(this, nodeId, actualChild);
+ parent.childrenByName.put(actualSegment.getName(), newChild);
+ }
+ }
+
+ }
+
+ /**
+ * Determine whether this node has been marked as having changes.
+ *
+ * @param recursive true if the nodes under this node should be checked, or false if only this node should be checked
+ * @return true if there are changes in the specified scope, or false otherwise
+ */
+ public final boolean isChanged( boolean recursive ) {
+ assert !isStale();
+ return recursive ? this.changed || this.changedBelow : this.changed;
+ }
+
+ /**
+ * This method determines whether this node, or any nodes below it, contain changes that depend on nodes that are outside
+ * of this branch.
+ *
+ * @return true if this branch has nodes with changes dependent on nodes outside of this branch
+ */
+ public boolean containsChangesWithExternalDependencies() {
+ assert !isStale();
+ if (!isChanged(true)) {
+ // There are no changes in this branch ...
+ return false;
+ }
+ // Need to make sure that nodes were not moved into or out of this branch, since that would mean that we
+ // cannot refresh this branch without also refreshing the other affected branches (per the JCR specification) ...
+ for (Map.Entry<NodeId, Dependencies> entry : cache.changeDependencies.entrySet()) {
+ Dependencies dependency = entry.getValue();
+ NodeId nodeId = entry.getKey();
+ Node<Payload, PropertyPayload> changedNode = cache.nodes.get(nodeId);
+
+ // First, check whether the changed node is within the branch ...
+ if (!changedNode.isAtOrBelow(this)) {
+ // The node is not within this branch, so the original parent must not be at or below this node ...
+ if (cache.nodes.get(dependency.getMovedFrom()).isAtOrBelow(this)) {
+ return false;
+ }
+ // None of the other dependencies can be within this branch ...
+ for (NodeId dependentId : dependency.getRequireChangesTo()) {
+ // The dependent node must not be at or below this node ...
+ if (cache.nodes.get(dependentId).isAtOrBelow(this)) {
+ return false;
+ }
+ }
+ // Otherwise, continue with the next change ...
+ continue;
+ }
+ // The changed node is within this branch!
+
+ // Second, check whether this node was moved from outside this branch ...
+ if (dependency.getMovedFrom() != null) {
+ Node<Payload, PropertyPayload> originalParent = cache.nodes.get(dependency.getMovedFrom());
+ // The original parent must be at or below this node ...
+ if (!originalParent.isAtOrBelow(this)) {
+ return false;
+ }
+ // All of the other dependencies must be within this branch ...
+ for (NodeId dependentId : dependency.getRequireChangesTo()) {
+ // The dependent node must not be at or below this node ...
+ if (!cache.nodes.get(dependentId).isAtOrBelow(this)) {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Clear any transient changes that have been accumulated in this node.
+ *
+ * @see #markAsChanged()
+ */
+ public void clearChanges() {
+ assert !isStale();
+ if (this.changed) {
+ this.changed = false;
+ this.changedBelow = false;
+ unload();
+ } else {
+ if (!this.changedBelow) return;
+ // This node has not changed but something below has, so call to the children ...
+ if (childrenByName != null && childrenByName != cache.NO_CHILDREN) {
+ for (Node<Payload, PropertyPayload> child : childrenByName.values()) {
+ child.clearChanges();
+ }
+ }
+ this.changedBelow = false;
+ }
+ // Update the parent ...
+ if (this.parent != null) this.parent.recomputeChangedBelow();
+ }
+
+ /**
+ * Mark this node as having changes.
+ *
+ * @see #clearChanges()
+ */
+ public final void markAsChanged() {
+ assert !isStale();
+ this.changed = true;
+ if (this.parent != null) this.parent.markAsChangedBelow();
+ }
+
+ protected final void markAsChangedBelow() {
+ if (!this.changedBelow) {
+ this.changedBelow = true;
+ if (this.parent != null) this.parent.markAsChangedBelow();
+ }
+ }
+
+ protected final void recomputeChangedBelow() {
+ if (!this.changedBelow) return; // we're done
+ // there are changes ...
+ assert childrenByName != null;
+ for (Node<Payload, PropertyPayload> child : childrenByName.values()) {
+ if (child.isChanged(true)) {
+ this.markAsChangedBelow();
+ return;
+ }
+ }
+ // No changes found ...
+ this.changedBelow = false;
+ if (this.parent != null) this.parent.recomputeChangedBelow();
+ }
+
+ /**
+ * Move this node from its current location so that is is a child of the supplied parent.
+ *
+ * @param parent the new parent for this node; may not be null
+ * @throws RepositorySourceException if the parent node is to be loaded but a problem is encountered while doing so
+ * @throws IllegalArgumentException if this is the root node
+ */
+ public void moveTo( Node<Payload, PropertyPayload> parent ) {
+ moveTo(parent, null, true);
+ }
+
+ /**
+ * Move this node from its current location so that is is a child of the supplied parent, renaming the node in the
+ * process.
+ *
+ * @param parent the new parent for this node; may not be null
+ * @param newNodeName the new name for the node, or null if the node should keep the same name
+ * @throws RepositorySourceException if the parent node is to be loaded but a problem is encountered while doing so
+ * @throws IllegalArgumentException if this is the root node
+ */
+ public void moveTo( Node<Payload, PropertyPayload> parent,
+ Name newNodeName ) {
+ moveTo(parent, newNodeName, true);
+ }
+
+ /**
+ * Move this node from its current location so that is is a child of the supplied parent.
+ *
+ * @param parent the new parent for this node; may not be null
+ * @param newNodeName the new name for the node, or null if the node should keep the same name
+ * @param useBatch true if this operation should be performed using the session's current batch operation and executed
+ * upon {@link GraphSession#save()}, or false if the move should be performed immediately
+ * @throws RepositorySourceException if the parent node is to be loaded but a problem is encountered while doing so
+ * @throws IllegalArgumentException if this is the root node
+ */
+ protected void moveTo( Node<Payload, PropertyPayload> parent,
+ Name newNodeName,
+ boolean useBatch ) {
+ final Node<Payload, PropertyPayload> child = this;
+ assert !parent.isStale();
+ assert child.parent != this;
+ assert !child.isRoot();
+ if (newNodeName == null) newNodeName = getName();
+
+ // Check authorization ...
+ cache.authorizer.checkPermissions(parent.getPath(), Action.ADD_NODE);
+ cache.authorizer.checkPermissions(child.getPath().getParent(), Action.REMOVE);
+
+ parent.load();
+ if (parent.childrenByName == cache.NO_CHILDREN) {
+ parent.childrenByName = Multimaps.newLinkedListMultimap();
+ }
+ Name childName = child.getName();
+ List<Node<Payload, PropertyPayload>> currentChildren = parent.childrenByName.get(childName);
+ currentChildren.add(child);
+ parent.markAsChanged();
+ // Remove the child from it's existing parent ...
+ final Node<Payload, PropertyPayload> oldParent = child.parent;
+ // Record the operation ...
+ if (useBatch) {
+ if (newNodeName.equals(getName())) {
+ cache.operations.move(child.getLocation()).into(parent.getLocation());
+ } else {
+ cache.operations.move(child.getLocation()).as(newNodeName).into(parent.getLocation());
+ }
+ } else {
+ if (newNodeName.equals(getName())) {
+ cache.store.move(child.getLocation()).into(parent.getLocation());
+ } else {
+ cache.store.move(child.getLocation()).as(newNodeName).into(parent.getLocation());
+ }
+ }
+ cache.recordMove(child, oldParent, parent);
+ child.remove();
+ // Set the new parent to this node ...
+ child.parent = parent;
+ // Update the new child with the correct location ...
+ Path.Segment segment = cache.pathFactory.createSegment(childName, currentChildren.size());
+ child.updateLocation(segment);
+ }
+
+ /**
+ * Copy this node (and all nodes below it) and place the copy under the supplied parent location. The new copy will be
+ * appended to any existing children of the supplied parent node, and will be given the appropriate same-name-sibling
+ * index.
+ *
+ * @param parent the new parent for the new copy; may not be null
+ * @throws RepositorySourceException if the parent node is to be loaded but a problem is encountered while doing so
+ * @throws IllegalArgumentException if this is the root node
+ */
+ public void copyTo( Node<Payload, PropertyPayload> parent ) {
+ final Node<Payload, PropertyPayload> child = this;
+ assert !parent.isStale();
+ assert child.parent != this;
+ assert !child.isRoot();
+
+ // Check authorization ...
+ cache.authorizer.checkPermissions(parent.getPath(), Action.ADD_NODE);
+ cache.authorizer.checkPermissions(child.getPath(), Action.READ);
+
+ parent.load();
+ if (parent.childrenByName == cache.NO_CHILDREN) {
+ parent.childrenByName = Multimaps.newLinkedListMultimap();
+ }
+ Name childName = child.getName();
+ // Figure out the name and SNS of the new copy ...
+ List<Node<Payload, PropertyPayload>> currentChildren = parent.childrenByName.get(childName);
+ Location copyLocation = Location.create(cache.pathFactory.create(parent.getPath(), childName, currentChildren.size()));
+
+ // Perform the copy ...
+ cache.operations.copy(child.getLocation()).to(copyLocation);
+
+ // Add the child to the parent ...
+ cache.createNode(parent, cache.idFactory.create(), copyLocation);
+ parent.markAsChanged();
+ }
+
+ /**
+ * Clone this node (and all nodes below it). The new copy will be appended to the existing children of the
+ * {@link #getParent() parent}, and will be given the appropriate same-name-sibling index.
+ * <p>
+ * This is equivalent to calling <code>node.copyTo(node.getParent())</code>
+ * </p>
+ *
+ * @throws IllegalArgumentException if this is the root node
+ */
+ public void cloneNode() {
+ copyTo(getParent());
+ }
+
+ /**
+ * Remove this node from it's parent. Note that locations are <i>not</i> updated, since they will be updated if this node
+ * is added to a different parent. However, the locations of same-name-siblings under the parent <i>are</i> updated.
+ */
+ protected void remove() {
+ assert !isStale();
+ assert this.parent != null;
+ assert this.parent.isLoaded();
+ assert this.parent.childrenByName != null;
+ assert this.parent.childrenByName != cache.NO_CHILDREN;
+ this.parent.markAsChanged();
+ Name name = getName();
+ List<Node<Payload, PropertyPayload>> childrenWithSameName = this.parent.childrenByName.get(name);
+ this.parent = null;
+ if (childrenWithSameName.size() == 1) {
+ // No same-name-siblings ...
+ childrenWithSameName.clear();
+ } else {
+ // There is at least one other sibling with the same name ...
+ int lastIndex = childrenWithSameName.size() - 1;
+ assert lastIndex > 0;
+ int index = childrenWithSameName.indexOf(this);
+ // remove this node ...
+ childrenWithSameName.remove(index);
+ if (index != lastIndex) {
+ // There are same-name-siblings that have higher SNS indexes that this node had ...
+ for (int i = index; i != lastIndex; ++i) {
+ Node<Payload, PropertyPayload> sibling = childrenWithSameName.get(i);
+ Path.Segment segment = cache.pathFactory.createSegment(name, i + 1);
+ sibling.updateLocation(segment);
+ }
+ }
+ }
+ }
+
+ /**
+ * Remove this node from it's parent and destroy it's contents. The location of sibling nodes with the same name will be
+ * updated, and the node and all nodes below it will be destroyed and removed from the cache.
+ */
+ public void destroy() {
+ assert !isStale();
+ // Check authorization ...
+ cache.authorizer.checkPermissions(getPath(), Action.REMOVE);
+ // Remove the node from its parent ...
+ remove();
+ // This node was successfully removed, so now remove it from the cache ...
+ cache.recordDelete(this);
+ }
+
+ public final boolean isRoot() {
+ return this.parent == null;
+ }
+
+ /**
+ * Determine whether this node is stale because it was dropped from the cache.
+ *
+ * @return true if the node is stale and should no longer be used
+ */
+ public boolean isStale() {
+ // Find the root of this node ...
+ Node<?, ?> node = this;
+ while (node.parent != null) {
+ node = node.parent;
+ }
+ // The root of this branch MUST be the actual root of the cache
+ return node != cache.root;
+ }
+
+ /**
+ * Get this node's parent node.
+ *
+ * @return the parent node
+ */
+ public final Node<Payload, PropertyPayload> getParent() {
+ assert !isStale();
+ return parent;
+ }
+
+ /**
+ * @return nodeId
+ */
+ public final NodeId getNodeId() {
+ return nodeId;
+ }
+
+ /**
+ * Get the name of this node, without any same-name-sibling index.
+ *
+ * @return the name; never null
+ */
+ public final Name getName() {
+ return location.getPath().getLastSegment().getName();
+ }
+
+ /**
+ * Get the {@link Path.Segment path segment} for this node.
+ *
+ * @return the path segment; never null
+ */
+ public final Path.Segment getSegment() {
+ return location.getPath().getLastSegment();
+ }
+
+ /**
+ * Get the current path to this node.
+ *
+ * @return the current path; never null
+ */
+ public final Path getPath() {
+ return location.getPath();
+ }
+
+ /**
+ * Get the current location for this node.
+ *
+ * @return the current location; never null
+ */
+ public final Location getLocation() {
+ return location;
+ }
+
+ /**
+ * Get the child with the supplied segment.
+ *
+ * @param segment the segment of the child
+ * @return the child with the supplied name and SNS index, or null if the children have not yet been loaded
+ * @throws PathNotFoundException if the children have been loaded and the child does not exist
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public Node<Payload, PropertyPayload> getChild( Path.Segment segment ) {
+ return getChild(segment.getName(), segment.getIndex());
+ }
+
+ /**
+ * Get the first child matching the name and lowest SNS index
+ *
+ * @param name the name of the child
+ * @return the first child with the supplied name, or null if the children have not yet been loaded
+ * @throws PathNotFoundException if the children have been loaded and the child does not exist
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public Node<Payload, PropertyPayload> getFirstChild( Name name ) {
+ return getChild(name, 1);
+ }
+
+ /**
+ * Get the child with the supplied name and SNS index.
+ *
+ * @param name the name of the child
+ * @param sns the same-name-sibling index; must be 1 or more
+ * @return the child with the supplied name and SNS index; never null
+ * @throws PathNotFoundException if the children have been loaded and the child does not exist
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public Node<Payload, PropertyPayload> getChild( Name name,
+ int sns ) {
+ load();
+ List<Node<Payload, PropertyPayload>> children = childrenByName.get(name); // never null
+ try {
+ return children.get(sns - 1); // SNS is 1-based, index is 0-based
+ } catch (IndexOutOfBoundsException e) {
+ Path missingPath = cache.pathFactory.create(getPath(), name, sns);
+ throw new PathNotFoundException(Location.create(missingPath), getPath());
+ }
+ }
+
+ /**
+ * Get an iterator over the children that have the supplied name.
+ *
+ * @param name the of the child nodes to be returned; may not be null
+ * @return an unmodifiable iterator over the cached children that have the supplied name; never null but possibly empty
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public Iterable<Node<Payload, PropertyPayload>> getChildren( Name name ) {
+ load();
+ final Collection<Node<Payload, PropertyPayload>> children = childrenByName.get(name);
+ return new Iterable<Node<Payload, PropertyPayload>>() {
+ public Iterator<Node<Payload, PropertyPayload>> iterator() {
+ return new ReadOnlyIterator<Node<Payload, PropertyPayload>>(children.iterator());
+ }
+ };
+ }
+
+ /**
+ * Get an iterator over the children.
+ *
+ * @return an unmodifiable iterator over the cached children; never null
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public Iterable<Node<Payload, PropertyPayload>> getChildren() {
+ load();
+ final Collection<Node<Payload, PropertyPayload>> children = childrenByName.values();
+ return new Iterable<Node<Payload, PropertyPayload>>() {
+ public Iterator<Node<Payload, PropertyPayload>> iterator() {
+ return new ReadOnlyIterator<Node<Payload, PropertyPayload>>(children.iterator());
+ }
+ };
+ }
+
+ /**
+ * Get the number of children.
+ *
+ * @return the number of children in the cache
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public int getChildrenCount() {
+ load();
+ return childrenByName.size();
+ }
+
+ /**
+ * Get the number of children that have the same supplied name.
+ *
+ * @param name the name of the children to count
+ * @return the number of children in the cache
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public int getChildrenCount( Name name ) {
+ load();
+ return childrenByName.get(name).size();
+ }
+
+ /**
+ * Determine if this node is a leaf node with no children.
+ *
+ * @return true if this node has no children
+ * @throws RepositorySourceException if there is a problem loading this node's information from the store
+ */
+ public boolean isLeaf() {
+ load();
+ return childrenByName.isEmpty();
+ }
+
+ /**
+ * Get from this node the property with the supplied name.
+ *
+ * @param name the property name; may not be null
+ * @return the property with the supplied name, or null if there is no such property on this node
+ */
+ public PropertyInfo<PropertyPayload> getProperty( Name name ) {
+ load();
+ return properties.get(name);
+ }
+
+ /**
+ * Set the supplied property information on this node.
+ *
+ * @param property the new property; may not be null
+ * @param isMultiValued true if the property is multi-valued
+ * @param payload the optional payload for this property; may be null
+ * @return the previous information for the property, or null if there was no previous property
+ */
+ public PropertyInfo<PropertyPayload> setProperty( Property property,
+ boolean isMultiValued,
+ PropertyPayload payload ) {
+ load();
+ cache.authorizer.checkPermissions(getPath(), Action.SET_PROPERTY);
+ Name name = property.getName();
+ PropertyInfo<PropertyPayload> previous = properties.get(name);
+ PropertyId id = null;
+ PropertyStatus status = null;
+ if (previous != null) {
+ id = previous.getPropertyId();
+ status = previous.getStatus(); // keep NEW or CHANGED status, but UNCHANGED -> CHANGED
+ if (status == PropertyStatus.UNCHANGED) status = PropertyStatus.CHANGED;
+ } else {
+ id = new PropertyId(getNodeId(), name);
+ status = PropertyStatus.NEW;
+ }
+ PropertyInfo<PropertyPayload> info = new PropertyInfo<PropertyPayload>(id, property, isMultiValued, status, payload);
+ properties.put(name, info);
+ cache.operations.set(property).on(location);
+ markAsChanged();
+ return previous;
+ }
+
+ /**
+ * Remove a property from this node.
+ *
+ * @param name the name of the property to be removed; may not be null
+ * @return the previous information for the property, or null if there was no previous property
+ */
+ public PropertyInfo<PropertyPayload> removeProperty( Name name ) {
+ load();
+ PropertyInfo<PropertyPayload> results = properties.remove(name);
+ markAsChanged();
+ cache.operations.remove(name).on(location);
+ return results;
+ }
+
+ /**
+ * Get the names of the properties on this node.
+ *
+ * @return the names of the properties; never null
+ */
+ public Set<Name> getPropertyNames() {
+ load();
+ return properties.keySet();
+ }
+
+ /**
+ * Get the information for each of the properties on this node.
+ *
+ * @return the information for each of the properties; never null
+ */
+ public Collection<PropertyInfo<PropertyPayload>> getProperties() {
+ load();
+ return properties.values();
+ }
+
+ /**
+ * Get the number of properties owned by this node.
+ *
+ * @return the number of properties; never negative
+ */
+ public int getPropertyCount() {
+ load();
+ return properties.size();
+ }
+
+ public boolean isAtOrBelow( Node<Payload, PropertyPayload> other ) {
+ Node<Payload, PropertyPayload> node = this;
+ while (node != null) {
+ if (node == other) return true;
+ node = node.getParent();
+ }
+ return false;
+ }
+
+ /**
+ * @return payload
+ */
+ public Payload getPayload() {
+ return payload;
+ }
+
+ /**
+ * @param payload Sets payload to the specified value.
+ */
+ public void setPayload( Payload payload ) {
+ this.payload = payload;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public final int hashCode() {
+ return nodeId.hashCode();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @SuppressWarnings( "unchecked" )
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof Node) {
+ Node<Payload, PropertyPayload> that = (Node<Payload, PropertyPayload>)obj;
+ if (!this.nodeId.equals(that.nodeId)) return false;
+ return this.location.equals(that.location);
+ }
+ return false;
+ }
+
+ /**
+ * Utility method to obtain a string representation that uses the namespace prefixes where appropriate.
+ *
+ * @param registry the namespace registry, or null if no prefixes should be used
+ * @return the string representation; never null
+ */
+ public String getString( NamespaceRegistry registry ) {
+ return "Cached node <" + nodeId + "> at " + location.getString(registry);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return getString(null);
+ }
+
+ /**
+ * Visit all nodes in the cache that are already loaded
+ *
+ * @param visitor the visitor; may not be null
+ */
+ public void onLoadedNodes( NodeVisitor<Payload, PropertyPayload> visitor ) {
+ if (this.isLoaded()) {
+ // Create a queue. This queue will contain all the nodes to be visited,
+ // so if loading is not forced, then the queue should only contain already-loaded nodes...
+ LinkedList<Node<Payload, PropertyPayload>> queue = new LinkedList<Node<Payload, PropertyPayload>>();
+ queue.add(this);
+ while (!queue.isEmpty()) {
+ Node<Payload, PropertyPayload> node = queue.poll();
+ // Get an iterator over the children *before* we visit the node
+ Iterator<Node<Payload, PropertyPayload>> iter = node.getChildren().iterator();
+ // Visit this node ...
+ if (visitor.visit(node)) {
+ // Visit the children ...
+ int index = -1;
+ while (iter.hasNext()) {
+ Node<Payload, PropertyPayload> child = iter.next();
+ if (child.isLoaded()) {
+ queue.add(++index, child);
+ }
+ }
+ }
+ }
+ }
+ visitor.finish();
+ }
+
+ /**
+ * Visit all loaded and unloaded nodes in the cache.
+ *
+ * @param visitor the visitor; may not be null
+ */
+ public void onCachedNodes( NodeVisitor<Payload, PropertyPayload> visitor ) {
+ // Create a queue. This queue will contain all the nodes to be visited,
+ // so if loading is not forced, then the queue should only contain already-loaded nodes...
+ LinkedList<Node<Payload, PropertyPayload>> queue = new LinkedList<Node<Payload, PropertyPayload>>();
+ queue.add(this);
+ while (!queue.isEmpty()) {
+ Node<Payload, PropertyPayload> node = queue.poll();
+ // Get an iterator over the children *before* we visit the node
+ Iterator<Node<Payload, PropertyPayload>> iter = node.getChildren().iterator();
+ // Visit this node ...
+ if (visitor.visit(node)) {
+ // Visit the children ...
+ int index = -1;
+ while (iter.hasNext()) {
+ Node<Payload, PropertyPayload> child = iter.next();
+ queue.add(++index, child);
+ }
+ }
+ }
+ visitor.finish();
+ }
+
+ /**
+ * Visit all changed nodes in the cache.
+ *
+ * @param visitor the visitor; may not be null
+ */
+ public void onChangedNodes( NodeVisitor<Payload, PropertyPayload> visitor ) {
+ if (this.isChanged(true)) {
+ // Create a queue. This queue will contain all the nodes to be visited ...
+ LinkedList<Node<Payload, PropertyPayload>> changedNodes = new LinkedList<Node<Payload, PropertyPayload>>();
+ changedNodes.add(this);
+ while (!changedNodes.isEmpty()) {
+ Node<Payload, PropertyPayload> node = changedNodes.poll();
+ // Visit this node ...
+ boolean visitChildren = true;
+ if (node.changed) {
+ visitChildren = visitor.visit(node);
+ }
+ if (visitChildren && node.changedBelow) {
+ // Visit the children ...
+ int index = -1;
+ Iterator<Node<Payload, PropertyPayload>> iter = node.getChildren().iterator();
+ while (iter.hasNext()) {
+ Node<Payload, PropertyPayload> child = iter.next();
+ if (node.isChanged(true)) {
+ changedNodes.add(++index, child);
+ }
+ }
+ }
+ }
+ }
+ visitor.finish();
+ }
+
+ /**
+ * Obtain a snapshot of the structure below this node.
+ *
+ * @param pathsOnly true if the snapshot should only include paths, or false if the entire locations should be included
+ * @return the snapshot
+ */
+ public StructureSnapshot<PropertyPayload> getSnapshot( final boolean pathsOnly ) {
+ final List<Snapshot<PropertyPayload>> snapshots = new ArrayList<Snapshot<PropertyPayload>>();
+ onCachedNodes(new NodeVisitor<Payload, PropertyPayload>() {
+ @Override
+ public boolean visit( Node<Payload, PropertyPayload> node ) {
+ snapshots.add(new Snapshot<PropertyPayload>(node, pathsOnly, true));
+ return node.isLoaded();
+ }
+ });
+ return new StructureSnapshot<PropertyPayload>(cache.context.getNamespaceRegistry(),
+ Collections.unmodifiableList(snapshots));
+ }
+ }
+
+ public static enum PropertyStatus {
+ NEW,
+ CHANGED,
+ UNCHANGED;
+ }
+
+ @Immutable
+ public static final class PropertyInfo<PropertyPayload> {
+ private final PropertyId propertyId;
+ private final Property property;
+ private final PropertyStatus status;
+ private final boolean multiValued;
+ private final PropertyPayload payload;
+
+ protected PropertyInfo( PropertyId propertyId,
+ Property property,
+ boolean multiValued,
+ PropertyStatus status,
+ PropertyPayload payload ) {
+ assert propertyId != null;
+ assert property != null;
+ assert status != null;
+ this.propertyId = propertyId;
+ this.property = property;
+ this.status = status;
+ this.multiValued = multiValued;
+ this.payload = payload;
+ }
+
+ /**
+ * Get the status of this property.
+ *
+ * @return the current status; never null
+ */
+ public PropertyStatus getStatus() {
+ return status;
+ }
+
+ /**
+ * Get the name of the property.
+ *
+ * @return the propert name; never null
+ */
+ public Name getName() {
+ return propertyId.getPropertyName();
+ }
+
+ /**
+ * Get the Graph API property object containing the values.
+ *
+ * @return the property object; never null
+ */
+ public Property getProperty() {
+ return property;
+ }
+
+ /**
+ * Get the identifier for this property.
+ *
+ * @return the property identifier; never null
+ */
+ public PropertyId getPropertyId() {
+ return propertyId;
+ }
+
+ /**
+ * Get the payload for this property.
+ *
+ * @return the payload; may be null if there is no payload
+ */
+ public PropertyPayload getPayload() {
+ return payload;
+ }
+
+ /**
+ * Determine whether this property has multiple values
+ *
+ * @return multiValued
+ */
+ public boolean isMultiValued() {
+ return multiValued;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return propertyId.hashCode();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof PropertyInfo) {
+ PropertyInfo<?> that = (PropertyInfo<?>)obj;
+ return propertyId.equals(that.getPropertyId());
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(propertyId);
+ if (payload != null) sb.append(payload);
+ if (property.isSingle()) {
+ sb.append(" with value ");
+ } else {
+ sb.append(" with values ");
+ }
+ sb.append(property.getValuesAsArray());
+ return sb.toString();
+ }
+ }
+
+ /**
+ * The node visitor.
+ *
+ * @param <NodePayload> the type of node payload object
+ * @param <PropertyPayloadType> the type of property payload object
+ */
+ @NotThreadSafe
+ public static abstract class NodeVisitor<NodePayload, PropertyPayloadType> {
+ /**
+ * Visit the supplied node, returning whether the children should be visited.
+ *
+ * @param node the node to be visited; never null
+ * @return true if the node's children should be visited, or false if no children should be visited
+ */
+ public abstract boolean visit( Node<NodePayload, PropertyPayloadType> node );
+
+ /**
+ * Method that should be called after all visiting has been done successfully (with no exceptions), including when no
+ * nodes were visited.
+ */
+ public void finish() {
+ }
+ }
+
+ /**
+ * An abstract base class for visitors that need to load nodes using a single batch for all read operations. To use, simply
+ * subclass and supply a {@link #visit(Node)} implementation that calls {@link #load(Node)} for each node that is to be
+ * loaded. When the visitor is {@link #finish() finished}, all of these nodes will be read from the store and loaded. The
+ * {@link #finishNodeAfterLoading(Node)} is called after each node is loaded, allowing the subclass to perform an operation on
+ * the newly-loaded nodes.
+ */
+ @NotThreadSafe
+ protected abstract class LoadNodesVisitor extends NodeVisitor<Payload, PropertyPayload> {
+ private Graph.Batch batch = GraphSession.this.store.batch();
+ private List<Node<Payload, PropertyPayload>> nodesToLoad = new LinkedList<Node<Payload, PropertyPayload>>();
+
+ /**
+ * Method that signals that the supplied node should be loaded (if it is not already loaded). This method should be called
+ * from within the {@link #visit(Node)} method of the subclass.
+ *
+ * @param node the node that should be loaded (if it is not already)
+ */
+ protected void load( Node<Payload, PropertyPayload> node ) {
+ if (node != null && !node.isLoaded()) {
+ nodesToLoad.add(node);
+ batch.read(node.getLocation());
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.NodeVisitor#finish()
+ */
+ @Override
+ public void finish() {
+ super.finish();
+ if (!nodesToLoad.isEmpty()) {
+ // Read all of the children in one batch ...
+ Results results = batch.execute();
+ // Now load all of the children into the correct node ...
+ for (Node<Payload, PropertyPayload> childToBeRead : nodesToLoad) {
+ org.jboss.dna.graph.Node persistentNode = results.getNode(childToBeRead.getLocation());
+ nodeOperations.update(persistentNode, childToBeRead);
+ finishNodeAfterLoading(childToBeRead);
+ }
+ }
+ }
+
+ /**
+ * Method that is called on each node loaded by this visitor. This method does nothing by default.
+ *
+ * @param node the just-loaded node; never null
+ */
+ protected void finishNodeAfterLoading( Node<Payload, PropertyPayload> node ) {
+ // do nothing
+ }
+ }
+
+ /**
+ * A visitor that ensures that all children of a node are loaded, and provides a hook to {@link #finishNodeAfterLoading(Node)
+ * post-process the parent}.
+ */
+ @NotThreadSafe
+ protected class LoadAllChildrenVisitor extends LoadNodesVisitor {
+ private List<Node<Payload, PropertyPayload>> parentsVisited = new LinkedList<Node<Payload, PropertyPayload>>();
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.NodeVisitor#visit(GraphSession.Node)
+ */
+ @Override
+ public boolean visit( Node<Payload, PropertyPayload> node ) {
+ parentsVisited.add(node);
+ Iterator<Node<Payload, PropertyPayload>> iter = node.getChildren().iterator();
+ while (iter.hasNext()) {
+ load(iter.next());
+ }
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see GraphSession.LoadNodesVisitor#finish()
+ */
+ @Override
+ public void finish() {
+ super.finish();
+ for (Node<Payload, PropertyPayload> parent : parentsVisited) {
+ finishParentAfterLoading(parent);
+ }
+ }
+
+ /**
+ * Method that is called at the end of the {@link #finish()} stage with each parent node whose children were all loaded.
+ *
+ * @param parentNode the parent of the just-loaded children; never null
+ */
+ protected void finishParentAfterLoading( Node<Payload, PropertyPayload> parentNode ) {
+ // do nothing
+ }
+ }
+
+ protected static final class Snapshot<PropertyPayload> {
+ private final Location location;
+ private final boolean isLoaded;
+ private final boolean isChanged;
+ private final Collection<PropertyInfo<PropertyPayload>> properties;
+ private final NodeId id;
+
+ protected Snapshot( Node<?, PropertyPayload> node,
+ boolean pathsOnly,
+ boolean includeProperties ) {
+ this.location = pathsOnly && node.getLocation().hasIdProperties() ? Location.create(node.getLocation().getPath()) : node.getLocation();
+ this.isLoaded = node.isLoaded();
+ this.isChanged = node.isChanged(false);
+ this.id = node.getNodeId();
+ this.properties = includeProperties ? node.getProperties() : null;
+ }
+
+ /**
+ * @return location
+ */
+ public Location getLocation() {
+ return location;
+ }
+
+ /**
+ * @return isChanged
+ */
+ public boolean isChanged() {
+ return isChanged;
+ }
+
+ /**
+ * @return isLoaded
+ */
+ public boolean isLoaded() {
+ return isLoaded;
+ }
+
+ /**
+ * @return id
+ */
+ public NodeId getId() {
+ return id;
+ }
+
+ /**
+ * @return properties
+ */
+ public Collection<PropertyInfo<PropertyPayload>> getProperties() {
+ return properties;
+ }
+ }
+
+ /**
+ * A read-only visitor that walks the cache to obtain a snapshot of the cache structure. The resulting snapshot contains the
+ * location of each node in the tree, including unloaded nodes.
+ *
+ * @param <PropertyPayload> the property payload
+ */
+ @Immutable
+ public static final class StructureSnapshot<PropertyPayload> implements Iterable<Snapshot<PropertyPayload>> {
+ private final List<Snapshot<PropertyPayload>> snapshotsInPreOrder;
+ private final NamespaceRegistry registry;
+
+ protected StructureSnapshot( NamespaceRegistry registry,
+ List<Snapshot<PropertyPayload>> snapshotsInPreOrder ) {
+ assert snapshotsInPreOrder != null;
+ this.snapshotsInPreOrder = snapshotsInPreOrder;
+ this.registry = registry;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Iterable#iterator()
+ */
+ public Iterator<Snapshot<PropertyPayload>> iterator() {
+ return snapshotsInPreOrder.iterator();
+ }
+
+ /**
+ * Get the Location for every node in this cache
+ *
+ * @return the node locations (in pre-order)
+ */
+ public List<Snapshot<PropertyPayload>> getSnapshotsInPreOrder() {
+ return snapshotsInPreOrder;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ int maxLength = 0;
+ for (Snapshot<PropertyPayload> snapshot : this) {
+ String path = snapshot.getLocation().getPath().getString(registry);
+ maxLength = Math.max(maxLength, path.length());
+ }
+ StringBuilder sb = new StringBuilder();
+ for (Snapshot<PropertyPayload> snapshot : this) {
+ Location location = snapshot.getLocation();
+ sb.append(StringUtil.justifyLeft(location.getPath().getString(registry), maxLength, ' '));
+ // Append the node identifier ...
+ sb.append(StringUtil.justifyRight(snapshot.getId().toString(), 10, ' '));
+ // Append the various state flags
+ if (snapshot.isChanged()) sb.append(" (*)");
+ else if (!snapshot.isLoaded()) sb.append(" (-)");
+ else sb.append(" ");
+ // Append the location's identifier properties ...
+ if (location.hasIdProperties()) {
+ sb.append(" ");
+ if (location.getIdProperties().size() == 1 && location.getUuid() != null) {
+ sb.append(location.getUuid());
+ } else {
+ boolean first = true;
+ sb.append('[');
+ for (Property property : location) {
+ sb.append(property.getString(registry));
+ if (first) first = false;
+ else sb.append(", ");
+ }
+ sb.append(']');
+ }
+ }
+ // Append the property information ...
+ if (snapshot.getProperties() != null) {
+ boolean first = true;
+ sb.append(" {");
+ for (PropertyInfo<?> info : snapshot.getProperties()) {
+ if (first) first = false;
+ else sb.append("} {");
+ sb.append(info.getProperty().getString(registry));
+ }
+ sb.append("}");
+ }
+ sb.append("\n");
+ }
+ return sb.toString();
+ }
+ }
+
+ @NotThreadSafe
+ protected static final class RefreshState<Payload, PropertyPayload> {
+ private final Set<Node<Payload, PropertyPayload>> refresh = new HashSet<Node<Payload, PropertyPayload>>();
+
+ public void markAsRequiringRefresh( Node<Payload, PropertyPayload> node ) {
+ refresh.add(node);
+ }
+
+ public boolean requiresRefresh( Node<Payload, PropertyPayload> node ) {
+ return refresh.contains(node);
+ }
+
+ public Set<Node<Payload, PropertyPayload>> getNodesToBeRefreshed() {
+ return refresh;
+ }
+ }
+
+ @NotThreadSafe
+ protected final static class Dependencies {
+ private Set<NodeId> requireChangesTo;
+ private NodeId movedFrom;
+
+ public Dependencies() {
+ }
+
+ /**
+ * @return movedFrom
+ */
+ public NodeId getMovedFrom() {
+ return movedFrom;
+ }
+
+ /**
+ * Record that this node is being moved from one parent to another. This method only records the original parent, so
+ * subsequent calls to this method do nothing.
+ *
+ * @param movedFrom the identifier of the original parent of this node
+ */
+ public void setMovedFrom( NodeId movedFrom ) {
+ if (this.movedFrom == null) this.movedFrom = movedFrom;
+ }
+
+ /**
+ * @return requireChangesTo
+ */
+ public Set<NodeId> getRequireChangesTo() {
+ return requireChangesTo != null ? requireChangesTo : Collections.<NodeId>emptySet();
+ }
+
+ /**
+ * @param other the other node that changes are dependent upon
+ */
+ public void addRequireChangesTo( NodeId other ) {
+ if (other == null) return;
+ if (requireChangesTo == null) {
+ requireChangesTo = new HashSet<NodeId>();
+ }
+ requireChangesTo.add(other);
+ }
+ }
+
+ /**
+ * An immutable identifier for a node, used within the {@link GraphSession}.
+ */
+ @Immutable
+ public final static class NodeId {
+
+ private final long nodeId;
+
+ /**
+ * Create a new node identifier.
+ *
+ * @param nodeId unique identifier
+ */
+ public NodeId( long nodeId ) {
+ this.nodeId = nodeId;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return (int)nodeId;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof NodeId) {
+ NodeId that = (NodeId)obj;
+ return this.nodeId == that.nodeId;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return Long.toString(nodeId);
+ }
+ }
+
+ /**
+ * An immutable identifier for a property on a node, used within the {@link GraphSession}.
+ */
+ @Immutable
+ public final static class PropertyId {
+ private final NodeId nodeId;
+ private final Name propertyName;
+ private final int hc;
+
+ public PropertyId( NodeId nodeId,
+ Name propertyName ) {
+ this.nodeId = nodeId;
+ this.propertyName = propertyName;
+ this.hc = HashCode.compute(this.nodeId, this.propertyName);
+ }
+
+ /**
+ * Get the identifier of the node on which the property exists.
+ *
+ * @return the node identifier; never null
+ */
+ public NodeId getNodeId() {
+ return nodeId;
+ }
+
+ /**
+ * Get the name of the property.
+ *
+ * @return the property name; never null
+ */
+ public Name getPropertyName() {
+ return propertyName;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return hc;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof PropertyId) {
+ PropertyId that = (PropertyId)obj;
+ if (this.hc != that.hc) return false;
+ if (!this.nodeId.equals(that.nodeId)) return false;
+ return this.propertyName.equals(that.propertyName);
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return this.nodeId.toString() + '@' + this.propertyName.toString();
+ }
+ }
+}
Property changes on: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/GraphSession.java
___________________________________________________________________
Name: svn:keywords
+ Id Revision
Name: svn:eol-style
+ LF
Added: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/InvalidStateException.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/InvalidStateException.java (rev 0)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/InvalidStateException.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -0,0 +1,65 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.graph.session;
+
+/**
+ *
+ */
+public class InvalidStateException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ */
+ public InvalidStateException() {
+ }
+
+ /**
+ * @param message
+ */
+ public InvalidStateException( String message ) {
+ super(message);
+
+ }
+
+ /**
+ * @param cause
+ */
+ public InvalidStateException( Throwable cause ) {
+ super(cause);
+
+ }
+
+ /**
+ * @param message
+ * @param cause
+ */
+ public InvalidStateException( String message,
+ Throwable cause ) {
+ super(message, cause);
+
+ }
+
+}
Property changes on: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/InvalidStateException.java
___________________________________________________________________
Name: svn:keywords
+ Id Revision
Name: svn:eol-style
+ LF
Added: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/ValidationException.java
===================================================================
--- trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/ValidationException.java (rev 0)
+++ trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/ValidationException.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -0,0 +1,65 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.graph.session;
+
+/**
+ *
+ */
+public class ValidationException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ */
+ public ValidationException() {
+ }
+
+ /**
+ * @param message
+ */
+ public ValidationException( String message ) {
+ super(message);
+
+ }
+
+ /**
+ * @param cause
+ */
+ public ValidationException( Throwable cause ) {
+ super(cause);
+
+ }
+
+ /**
+ * @param message
+ * @param cause
+ */
+ public ValidationException( String message,
+ Throwable cause ) {
+ super(message, cause);
+
+ }
+
+}
Property changes on: trunk/dna-graph/src/main/java/org/jboss/dna/graph/session/ValidationException.java
___________________________________________________________________
Name: svn:keywords
+ Id Revision
Name: svn:eol-style
+ LF
Modified: trunk/dna-graph/src/main/resources/org/jboss/dna/graph/GraphI18n.properties
===================================================================
--- trunk/dna-graph/src/main/resources/org/jboss/dna/graph/GraphI18n.properties 2009-07-09 16:22:06 UTC (rev 1080)
+++ trunk/dna-graph/src/main/resources/org/jboss/dna/graph/GraphI18n.properties 2009-07-09 16:23:09 UTC (rev 1081)
@@ -49,7 +49,7 @@
pathExpressionHasInvalidMatch = Invalid match expression "{0}" in the path expression "{1}"
messageDigestNotFound = The "{0}" message digest algorithm could not be found
unableToAccessResourceFileFromClassLoader = Unable to access "{0}" resource from the class loader
-pathNotFoundExceptionLowestExistingLocationFound = {0}; lowest existing path is {1}
+pathNotFoundExceptionLowestExistingLocationFound = Unable to find "{0}"; lowest existing path is "{1}"
executingRequest = Executing {0}
executedRequest = Executed {0}
@@ -101,9 +101,14 @@
federatedSourceDoesNotSupportCloningWorkspaces = {0} is a source that does not allow cloning workspaces
federatedSourceDoesNotSupportDestroyingWorkspaces = {0} is a source that does not allow destroying workspaces
unableToProjectSourceInformationIntoWorkspace = Unable to project source information at {0} in the "{1} federated repository source using projection {2}
-unableToCreateNodeUnderPlaceholder = Unable to create node "{0}" under {1} in the "{2}" workspace of the "{3}" federated repository because the parent is a placeholder
-unableToUpdatePlaceholder = Unable to update node {0} in the "{1}" workspace of the "{2}" federated repository because the node is a placeholder
-unableToDeletePlaceholder = Unable to delete node {0} in the "{1}" workspace of the "{2}" federated repository because the node is a placeholder
-copyLimitedToBeWithinSingleSource = Unable to copy {0} in the "{1}" workspace of the "{3}" federated repository into {2} in the "{3}" workspace: copy is only supported when the original and new locations are within the same source
-moveLimitedToBeWithinSingleSource = Unable to move {0} in the "{1}" workspace of the "{3}" federated repository into {2} in the "{3}" workspace: move is only supported when the original and new locations are within the same source
+unableToCreateNodeUnderPlaceholder = Unable to create node "{0}" under {1} in the "{2}" workspace of the "{3}" federarted repository because the parent is a placeholder
+unableToUpdatePlaceholder = Unable to update node {0} in the "{1}" workspace of the "{2}" federarted repository because the node is a placeholder
+unableToDeletePlaceholder = Unable to delete node {0} in the "{1}" workspace of the "{2}" federarted repository because the node is a placeholder
+copyLimitedToBeWithinSingleSource = Unable to copy {0} in the "{1}" workspace of the "{3}" federarted repository into {2} in the "{3}" workspace: copy is only supported when the original and new locations are within the same source
+moveLimitedToBeWithinSingleSource = Unable to move {0} in the "{1}" workspace of the "{3}" federarted repository into {2} in the "{3}" workspace: move is only supported when the original and new locations are within the same source
cloneLimitedToBeWithinSingleSource = Unable to clone {0} in the "{1}" workspace of the "{3}" federated repository into {2} in the "{3}" workspace: clone is only supported when the original and new locations are within the same source
+
+# Session
+unableToRefreshBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch = Unable to refresh "{0}" in workspace "{1}" because it contains changes that depend on changes to nodes outside of this branch
+unableToSaveBranchBecauseChangesDependOnChangesToNodesOutsideOfBranch = Unable to save "{0}" in workspace "{1}" because it contains changes that depend on changes to nodes outside of this branch
+nodeHasAlreadyBeenRemovedFromThisSession = Node "{0}" in workspace "{1} has already been removed from this session
Added: trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/GraphCacheTest.java
===================================================================
--- trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/GraphCacheTest.java (rev 0)
+++ trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/GraphCacheTest.java 2009-07-09 16:23:09 UTC (rev 1081)
@@ -0,0 +1,574 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.graph.session;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Graph;
+import org.jboss.dna.graph.connector.RepositoryConnection;
+import org.jboss.dna.graph.connector.RepositoryConnectionFactory;
+import org.jboss.dna.graph.connector.RepositorySourceException;
+import org.jboss.dna.graph.connector.inmemory.InMemoryRepositorySource;
+import org.jboss.dna.graph.property.Name;
+import org.jboss.dna.graph.property.Path;
+import org.jboss.dna.graph.property.PathFactory;
+import org.jboss.dna.graph.property.Property;
+import org.jboss.dna.graph.session.GraphSession.Node;
+import org.jboss.dna.graph.session.GraphSession.Operations;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ *
+ */
+public class GraphCacheTest {
+
+ protected ExecutionContext context;
+ protected InMemoryRepositorySource source;
+ private Graph store;
+ private GraphSession<Object, Object> cache;
+ private PathFactory pathFactory;
+ protected int numberOfConnections;
+
+ @Before
+ public void beforeEach() throws Exception {
+ context = new ExecutionContext();
+ pathFactory = context.getValueFactories().getPathFactory();
+ source = new InMemoryRepositorySource();
+ source.setName("store");
+ // Use a connection factory so we can count the number of connections that were made
+ RepositoryConnectionFactory connectionFactory = new RepositoryConnectionFactory() {
+ public RepositoryConnection createConnection( String sourceName ) throws RepositorySourceException {
+ if (source.getName().equals(sourceName)) {
+ ++numberOfConnections;
+ return source.getConnection();
+ }
+ return null;
+ }
+ };
+ store = Graph.create(source.getName(), connectionFactory, context);
+
+ // Load the store with content ...
+ store.importXmlFrom(getClass().getClassLoader().getResourceAsStream("cars.xml")).into("/");
+ numberOfConnections = 0; // reset the number of connections
+
+ Operations<Object, Object> nodeOps = null; // use default
+ String workspaceName = null; // use current
+ cache = new GraphSession<Object, Object>(store, workspaceName, nodeOps);
+ }
+
+ @Test
+ public void shouldHaveRootNodeWithCorrectNodeIdAndLocation() {
+ Node<Object, Object> node = cache.getRoot();
+ assertThat(node, is(notNullValue()));
+ assertThat(node.getNodeId(), is(notNullValue()));
+ assertThat(node.getLocation(), is(notNullValue()));
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldNotHaveAutomaticallyLoadedRootNode() {
+ assertThat(cache.getRoot().isLoaded(), is(false));
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldHaveRootNodeWithChildren() {
+ Node<Object, Object> node = cache.getRoot();
+ assertChildren(node, "Cars");
+ assertConnectionsUsed(1);
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldHaveNoExpirationIfSourceDoesNotHaveCachePolicy() {
+ Node<Object, Object> node = cache.getRoot();
+ node.load();
+ assertThat(node.getExpirationTimeInMillis(), is(Long.MAX_VALUE));
+ assertConnectionsUsed(1);
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldAutomaticallyLoadNodesWhenNavigatingToChildren() {
+ Node<Object, Object> root = cache.getRoot();
+ assertThat(root.isLoaded(), is(false));
+ assertChildren(root, "Cars"); // causes loading of the root node
+ assertThat(root.isLoaded(), is(true));
+ assertConnectionsUsed(1);
+
+ Node<Object, Object> cars = root.getChildren().iterator().next(); // only one child
+ assertThat(cars.isLoaded(), is(false));
+ assertChildren(cars, "Hybrid", "Sports", "Luxury", "Utility");
+ assertConnectionsUsed(1);
+ assertThat(cars.isLoaded(), is(true));
+ assertThat(cars.getParent(), is(sameInstance(root)));
+
+ Node<Object, Object> sports = cars.getChild(segment("Sports"));
+ assertThat(sports.isLoaded(), is(false));
+ assertChildren(sports, "Aston Martin DB9", "Infiniti G37");
+ assertConnectionsUsed(1);
+ assertThat(sports.isLoaded(), is(true));
+ assertThat(sports.getParent(), is(sameInstance(cars)));
+
+ Node<Object, Object> g37 = sports.getChild(segment("Infiniti G37"));
+ assertThat(g37.isLoaded(), is(false));
+ assertChildren(g37);
+ assertConnectionsUsed(1);
+ assertThat(g37.isLoaded(), is(true));
+ assertThat(g37.isLeaf(), is(true));
+ assertThat(g37.getParent(), is(sameInstance(sports)));
+
+ // Try another branch ...
+ Node<Object, Object> utility = cars.getChild(segment("Utility"));
+ assertThat(utility.isLoaded(), is(false));
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150");
+ assertConnectionsUsed(1);
+ assertThat(utility.isLoaded(), is(true));
+ assertThat(utility.getParent(), is(sameInstance(cars)));
+
+ Node<Object, Object> lr3 = utility.getChild(segment("Land Rover LR3"));
+ assertThat(lr3.isLoaded(), is(false));
+ assertChildren(lr3);
+ assertConnectionsUsed(1);
+ assertThat(lr3.isLoaded(), is(true));
+ assertThat(lr3.isLeaf(), is(true));
+ assertThat(lr3.getParent(), is(sameInstance(utility)));
+
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldFindNodesByPath() {
+ Node<Object, Object> g37 = cache.findNodeWith(path("/Cars/Sports/Infiniti G37")); // loads the node and all parents
+ assertConnectionsUsed(1);
+ assertThat(g37.isLoaded(), is(true));
+ assertChildren(g37);
+ assertThat(g37.isLoaded(), is(true));
+ assertThat(g37.isLeaf(), is(true));
+
+ Node<Object, Object> sports = g37.getParent();
+ assertThat(sports.isLoaded(), is(true));
+ assertChildren(sports, "Aston Martin DB9", "Infiniti G37");
+
+ Node<Object, Object> cars = sports.getParent();
+ assertThat(cars.isLoaded(), is(true));
+ assertChildren(cars, "Hybrid", "Sports", "Luxury", "Utility");
+
+ Node<Object, Object> root = cars.getParent();
+ assertThat(root, is(sameInstance(cache.getRoot())));
+ assertThat(root.isLoaded(), is(true));
+ assertChildren(root, "Cars"); // causes loading of the root node
+
+ assertNoMoreConnectionsUsed();
+
+ // Try another branch that should not be loaded...
+ Node<Object, Object> utility = cars.getChild(segment("Utility"));
+ assertThat(utility.isLoaded(), is(false));
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150");
+ assertConnectionsUsed(1);
+ assertThat(utility.isLoaded(), is(true));
+ assertThat(utility.getParent(), is(sameInstance(cars)));
+
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldFindNodesById() {
+ cache.findNodeWith(path("/Cars/Sports/Infiniti G37")); // loads the node and all parents
+ assertConnectionsUsed(1); // "Utility" was found because it is child of "Cars" loaded when "Sports" was loaded
+
+ cache.getRoot().onCachedNodes(new GraphSession.NodeVisitor<Object, Object>() {
+ @SuppressWarnings( "synthetic-access" )
+ @Override
+ public boolean visit( Node<Object, Object> node ) {
+ assertThat(cache.findNodeWith(node.getNodeId(), null), is(sameInstance(node)));
+ return true;
+ }
+ });
+ }
+
+ @Test
+ public void shouldFindNodesByLocation() {
+ cache.findNodeWith(path("/Cars/Sports/Infiniti G37")); // loads the node and all parents
+ assertConnectionsUsed(1); // "Utility" was found because it is child of "Cars" loaded when "Sports" was loaded
+
+ cache.getRoot().onCachedNodes(new GraphSession.NodeVisitor<Object, Object>() {
+ @SuppressWarnings( "synthetic-access" )
+ @Override
+ public boolean visit( Node<Object, Object> node ) {
+ assertThat(cache.findNodeWith(null, node.getLocation().getPath()), is(sameInstance(node)));
+ return true;
+ }
+ });
+ }
+
+ @Test
+ public void shouldFindNodesByIdAfterClearing() {
+ Node<Object, Object> g37 = cache.findNodeWith(path("/Cars/Sports/Infiniti G37")); // loads the node and all parents
+ assertConnectionsUsed(1);
+ assertThat(g37.isLoaded(), is(true));
+ assertChildren(g37);
+ assertThat(g37.isLoaded(), is(true));
+ assertThat(g37.isLeaf(), is(true));
+
+ Node<Object, Object> sports = g37.getParent();
+ Node<Object, Object> cars = sports.getParent();
+ Node<Object, Object> root = cars.getParent();
+
+ assertNoMoreConnectionsUsed();
+
+ cache.getRoot().unload();
+
+ Node<Object, Object> g37_b = cache.findNodeWith(g37.getNodeId(), g37.getPath());
+ assertConnectionsUsed(1);
+
+ Node<Object, Object> sports_b = g37_b.getParent();
+ Node<Object, Object> cars_b = sports_b.getParent();
+ Node<Object, Object> root_b = cars_b.getParent();
+ assertThat(g37_b, is(not(sameInstance(g37))));
+ assertThat(sports_b, is(not(sameInstance(sports))));
+ assertThat(cars_b, is(not(sameInstance(cars))));
+ assertThat(root_b, is(sameInstance(root)));
+ assertThat(g37_b.isLeaf(), is(true));
+ assertChildren(sports_b, "Aston Martin DB9", "Infiniti G37");
+ assertChildren(cars_b, "Hybrid", "Sports", "Luxury", "Utility");
+ assertChildren(root_b, "Cars");
+
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldMoveBranchAndRefresh() {
+ Node<Object, Object> sports = cache.findNodeWith(path("/Cars/Sports"));
+ Node<Object, Object> utility = cache.findNodeWith(path("/Cars/Utility"));
+ assertConnectionsUsed(1); // "Utility" was found because it is child of "Cars" loaded when "Sports" was loaded
+
+ sports.moveTo(utility);
+ assertConnectionsUsed(1); // "Utility" was not fully loaded before
+ assertNoMoreConnectionsUsed();
+
+ Node<Object, Object> cars = cache.findNodeWith(path("/Cars"));
+
+ for (int i = 0; i != 3; ++i) {
+ assertChildren(cars, "Hybrid", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150", "Sports");
+ assertThat(sports.getParent(), is(utility));
+ assertThat(utility.getParent(), is(cars));
+
+ // Ensure that the changes were recorded appropriately ...
+ assertThat(cars.isChanged(false), is(true));
+ assertThat(sports.isChanged(false), is(false));
+ assertThat(utility.isChanged(false), is(true));
+ assertThat(cache.hasPendingChanges(), is(true));
+ assertThat(cache.changeDependencies.size(), is(1));
+ assertThat(cache.changeDependencies.get(sports.getNodeId()).getMovedFrom(), is(cars.getNodeId()));
+ assertThat(cache.operations.isExecuteRequired(), is(true));
+
+ if (i == 0) {
+ // 1st time: Refreshing "Utility" shouldn't work because "/Cars" was involved in the same move ...
+ try {
+ cache.refresh(utility, false);
+ fail("Expected exception from the call to refresh");
+ } catch (InvalidStateException e) {
+ // expected ...
+ }
+ } else if (i == 1) {
+ // 2nd time: refresh "/Cars" but keep the changes ...
+ cache.refresh(cars, true);
+ } else if (i == 2) {
+ // 3rd time:
+ cache.refresh(cars, false);
+ }
+ }
+
+ // Now the state should be back to the original representation, but we need to refind the nodes ...
+ sports = cache.findNodeWith(path("/Cars/Sports"));
+ utility = cache.findNodeWith(path("/Cars/Utility"));
+ cars = cache.findNodeWith(path("/Cars"));
+
+ assertChildren(cars, "Hybrid", "Sports", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150");
+ assertThat(sports.getParent(), is(cars));
+ assertThat(utility.getParent(), is(cars));
+
+ // Now there should be no changes ...
+ assertNoChanges();
+ System.out.println(cache.root.getSnapshot(false));
+ }
+
+ @Test
+ public void shouldMoveBranchAndSaveBranch() {
+ Node<Object, Object> sports = cache.findNodeWith(path("/Cars/Sports"));
+ Node<Object, Object> utility = cache.findNodeWith(path("/Cars/Utility"));
+ assertConnectionsUsed(1); // "Utility" was found because it is child of "Cars" loaded when "Sports" was loaded
+
+ sports.moveTo(utility);
+ assertConnectionsUsed(1); // "Utility" was not fully loaded before
+ assertNoMoreConnectionsUsed();
+
+ Node<Object, Object> cars = cache.findNodeWith(path("/Cars"));
+ Node<Object, Object> root = cache.getRoot();
+
+ for (int i = 0; i != 2; ++i) {
+ assertChildren(cars, "Hybrid", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150", "Sports");
+ assertThat(sports.getParent(), is(utility));
+ assertThat(utility.getParent(), is(cars));
+
+ // Ensure that the changes were recorded appropriately ...
+ assertThat(cars.isChanged(false), is(true));
+ assertThat(sports.isChanged(false), is(false));
+ assertThat(utility.isChanged(false), is(true));
+ assertThat(cache.hasPendingChanges(), is(true));
+ assertThat(cache.changeDependencies.size(), is(1));
+ assertThat(cache.changeDependencies.get(sports.getNodeId()).getMovedFrom(), is(cars.getNodeId()));
+ assertThat(cache.operations.isExecuteRequired(), is(true));
+
+ if (i == 0) {
+ // 1st time: Saving "Utility" shouldn't work because "/Cars" was involved in the same move ...
+ try {
+ cache.save(utility);
+ fail("Expected exception from the call to save");
+ } catch (InvalidStateException e) {
+ // expected ...
+ }
+ } else if (i == 1) {
+ // 2nd time: Save "/Cars" but keep the changes ...
+ assertConnectionsUsed(0);
+ cache.save(cars);
+ assertConnectionsUsed(2); // 1 to load children required by validation, 1 to perform save
+ }
+ // i=2 do nothing
+ }
+
+ // The affected nodes should now be stale ...
+ assertThat(sports.isStale(), is(true));
+ assertThat(utility.isStale(), is(true));
+ assertThat(cars.isStale(), is(false)); // not stale because it was unloaded
+ assertThat(cars.isLoaded(), is(false));
+ assertThat(root.isStale(), is(false)); // not touched during saves
+
+ // Now the state should reflect our changes, but we need to refind the nodes ...
+ sports = cache.findNodeWith(path("/Cars/Utility/Sports"));
+ assertConnectionsUsed(1);
+ utility = cache.findNodeWith(path("/Cars/Utility"));
+ assertNoMoreConnectionsUsed();
+
+ assertChildren(cars, "Hybrid", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150", "Sports");
+ assertThat(sports.getParent(), is(utility));
+ assertThat(utility.getParent(), is(cars));
+
+ // Now there should be no changes ...
+ assertNoChanges();
+
+ System.out.println(cache.root.getSnapshot(false));
+ }
+
+ @Test
+ public void shouldMoveBranchAndSaveAll() {
+ Node<Object, Object> sports = cache.findNodeWith(path("/Cars/Sports"));
+ Node<Object, Object> utility = cache.findNodeWith(path("/Cars/Utility"));
+ assertConnectionsUsed(1); // "Utility" was found because it is child of "Cars" loaded when "Sports" was loaded
+
+ sports.moveTo(utility);
+ assertConnectionsUsed(1); // "Utility" was not fully loaded before
+ assertNoMoreConnectionsUsed();
+
+ Node<Object, Object> cars = cache.findNodeWith(path("/Cars"));
+ Node<Object, Object> root = cache.getRoot();
+
+ assertChildren(cars, "Hybrid", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150", "Sports");
+ assertThat(sports.getParent(), is(utility));
+ assertThat(utility.getParent(), is(cars));
+
+ // Ensure that the changes were recorded appropriately ...
+ assertThat(cars.isChanged(false), is(true));
+ assertThat(sports.isChanged(false), is(false));
+ assertThat(utility.isChanged(false), is(true));
+ assertThat(cache.hasPendingChanges(), is(true));
+ assertThat(cache.changeDependencies.size(), is(1));
+ assertThat(cache.changeDependencies.get(sports.getNodeId()).getMovedFrom(), is(cars.getNodeId()));
+ assertThat(cache.operations.isExecuteRequired(), is(true));
+
+ // Save the changes ...
+ assertConnectionsUsed(0);
+ cache.save();
+ assertConnectionsUsed(2); // 1 to load children required by validation, 1 to perform save
+
+ // The affected nodes should now be stale ...
+ assertThat(sports.isStale(), is(true));
+ assertThat(utility.isStale(), is(true));
+ assertThat(cars.isStale(), is(false)); // not stale because it was unloaded
+ assertThat(cars.isLoaded(), is(false));
+ assertThat(root.isStale(), is(false)); // not touched during saves
+
+ // Now the state should reflect our changes, but we need to refind the nodes ...
+ sports = cache.findNodeWith(path("/Cars/Utility/Sports"));
+ assertConnectionsUsed(1);
+ utility = cache.findNodeWith(path("/Cars/Utility"));
+ assertNoMoreConnectionsUsed();
+
+ assertChildren(cars, "Hybrid", "Luxury", "Utility");
+ assertChildren(utility, "Land Rover LR2", "Land Rover LR3", "Hummer H3", "Ford F-150", "Sports");
+ assertThat(sports.getParent(), is(utility));
+ assertThat(utility.getParent(), is(cars));
+
+ // Now there should be no changes ...
+ assertNoChanges();
+
+ // System.out.println(cache.root.getSnapshot(false));
+ }
+
+ @Test
+ public void shouldLoadSubgraphs() {
+ cache.setDepthForLoadingNodes(4);
+ Node<Object, Object> cars = cache.findNodeWith(path("/Cars")); // loads the node and all parents
+ assertChildren(cars, "Hybrid", "Sports", "Luxury", "Utility");
+ assertConnectionsUsed(1);
+
+ Node<Object, Object> sports = cache.findNodeWith(path("/Cars/Sports"));
+ Node<Object, Object> g37 = cache.findNodeWith(path("/Cars/Sports/Infiniti G37"));
+ Node<Object, Object> db9 = cache.findNodeWith(path("/Cars/Sports/Aston Martin DB9"));
+ assertConnectionsUsed(0); // should have been loaded with sports subgraph
+
+ assertThat(sports.isLoaded(), is(true));
+ assertThat(g37.isLoaded(), is(true));
+ assertThat(db9.isLoaded(), is(true));
+ assertChildren(sports, "Aston Martin DB9", "Infiniti G37");
+ assertChildren(g37);
+ assertChildren(db9);
+
+ assertNoMoreConnectionsUsed();
+ assertNoChanges();
+ }
+
+ @Test
+ public void shouldMarkAsChangedWhenSettingProperties() {
+ Node<Object, Object> g37 = cache.findNodeWith(path("/Cars/Sports/Infiniti G37"));
+ assertThat(g37.isChanged(false), is(false));
+
+ // Set the new property ...
+ Property newProperty = createProperty("something", "value1");
+ g37.setProperty(newProperty, false, null);
+ assertThat(g37.isChanged(false), is(true));
+ assertThat(cache.getRoot().isChanged(true), is(true));
+
+ // Save the changes ...
+ cache.save();
+ }
+
+ @Test
+ public void shouldClearPropertyChangesWhenRefreshing() {
+ Node<Object, Object> g37 = cache.findNodeWith(path("/Cars/Sports/Infiniti G37"));
+ assertThat(g37.isChanged(false), is(false));
+
+ // Set the new property ...
+ Property newProperty = createProperty("something", "value1");
+ g37.setProperty(newProperty, false, null);
+ assertThat(g37.isChanged(false), is(true));
+ assertThat(cache.getRoot().isChanged(true), is(true));
+
+ // Refresh the changes ...
+ cache.refresh(g37, false);
+
+ assertThat(g37.isChanged(true), is(false));
+ assertThat(cache.getRoot().isChanged(true), is(false));
+ assertNoChanges();
+ }
+
+ protected void assertChildren( Node<Object, Object> node,
+ String... childNames ) {
+ assertThat(node.getChildrenCount(), is(childNames.length));
+ List<Path.Segment> segments = new LinkedList<Path.Segment>();
+ for (String childName : childNames) {
+ segments.add(pathFactory.createSegment(childName));
+ }
+ Iterator<Path.Segment> expectedIter = segments.iterator();
+ Iterator<Node<Object, Object>> actualIter = node.getChildren().iterator();
+ while (expectedIter.hasNext() && actualIter.hasNext()) {
+ Node<Object, Object> actualNode = actualIter.next();
+ Path actualPath = actualNode.getPath();
+ Path.Segment actualSegment = actualPath.getLastSegment();
+ Path.Segment expectedSegment = expectedIter.next();
+ assertThat(actualSegment, is(expectedSegment));
+ }
+ assertThat(expectedIter.hasNext(), is(false));
+ assertThat(actualIter.hasNext(), is(false));
+ }
+
+ protected Name name( String name ) {
+ return context.getValueFactories().getNameFactory().create(name);
+ }
+
+ protected Path.Segment segment( String segment ) {
+ return context.getValueFactories().getPathFactory().createSegment(segment);
+ }
+
+ protected Path path( String path ) {
+ return context.getValueFactories().getPathFactory().create(path);
+ }
+
+ protected Property createProperty( String name,
+ Object... values ) {
+ return context.getPropertyFactory().create(name(name), values);
+ }
+
+ protected void assertChildrenNotLoaded( Node<Object, Object> node ) {
+ for (Node<Object, Object> child : node.getChildren()) {
+ assertThat(child.isLoaded(), is(false));
+ }
+ }
+
+ protected void assertNoChanges() {
+ assertThat(cache.hasPendingChanges(), is(false));
+ assertThat(cache.changeDependencies.isEmpty(), is(true));
+ assertThat(cache.operations.isExecuteRequired(), is(false));
+ }
+
+ protected void assertNoMoreConnectionsUsed() {
+ assertThat(numberOfConnections, is(0));
+ }
+
+ protected void assertConnectionsUsed( int number ) {
+ assertThat(numberOfConnections, is(number));
+ numberOfConnections = 0;
+ }
+
+}
Property changes on: trunk/dna-graph/src/test/java/org/jboss/dna/graph/session/GraphCacheTest.java
___________________________________________________________________
Name: svn:keywords
+ Id Revision
Name: svn:eol-style
+ LF
More information about the dna-commits
mailing list