/*
* Copyright (C) 2009 eXo Platform SAS.
*
* This is free software; you can redistribute it and/or modify it
* 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.
*
* This software 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.exoplatform.services.jcr.impl.core.version;
import org.exoplatform.services.jcr.access.AccessControlEntry;
import org.exoplatform.services.jcr.access.AccessControlList;
import org.exoplatform.services.jcr.core.nodetype.NodeTypeDataManager;
import org.exoplatform.services.jcr.dataflow.ItemState;
import org.exoplatform.services.jcr.datamodel.Identifier;
import org.exoplatform.services.jcr.datamodel.IllegalNameException;
import org.exoplatform.services.jcr.datamodel.InternalQName;
import org.exoplatform.services.jcr.datamodel.ItemData;
import org.exoplatform.services.jcr.datamodel.ItemType;
import org.exoplatform.services.jcr.datamodel.NodeData;
import org.exoplatform.services.jcr.datamodel.PropertyData;
import org.exoplatform.services.jcr.datamodel.QPath;
import org.exoplatform.services.jcr.datamodel.QPathEntry;
import org.exoplatform.services.jcr.datamodel.ValueData;
import org.exoplatform.services.jcr.impl.Constants;
import org.exoplatform.services.jcr.impl.core.SessionImpl;
import org.exoplatform.services.jcr.impl.dataflow.AbstractItemDataCopyVisitor;
import org.exoplatform.services.jcr.impl.dataflow.ItemDataCopyVisitor;
import org.exoplatform.services.jcr.impl.dataflow.ItemDataRemoveVisitor;
import org.exoplatform.services.jcr.impl.dataflow.TransientItemData;
import org.exoplatform.services.jcr.impl.dataflow.TransientNodeData;
import org.exoplatform.services.jcr.impl.dataflow.TransientPropertyData;
import org.exoplatform.services.jcr.impl.dataflow.TransientValueData;
import org.exoplatform.services.jcr.impl.dataflow.ValueDataUtil;
import org.exoplatform.services.jcr.impl.dataflow.session.SessionChangesLog;
import org.exoplatform.services.jcr.impl.dataflow.version.VersionHistoryDataHelper;
import org.exoplatform.services.jcr.impl.storage.JCRItemExistsException;
import org.exoplatform.services.jcr.util.IdGenerator;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.services.security.IdentityConstants;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;
import javax.jcr.ItemExistsException;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.version.OnParentVersionAction;
/**
* Created by The eXo Platform SAS.
*
* 14.12.2006
*
* @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a>
* @version $Id: ItemDataRestoreVisitor.java 14100 2008-05-12 10:53:47Z gazarenkov $
*/
public class ItemDataRestoreVisitor extends AbstractItemDataCopyVisitor
{
private final Log log = ExoLogger.getLogger("exo.jcr.component.core.ItemDataRestoreVisitor");
protected final boolean removeExisting;
protected final Stack<NodeDataContext> parents = new Stack<NodeDataContext>();
protected final NodeData context;
protected final NodeData history;
protected final InternalQName destName;
protected NodeData restored;
protected final SessionImpl userSession;
protected final SessionChangesLog changes;
/**
* Node paths for updating instead of deleting.
*/
protected final Set<QPath> updatingPath = new HashSet<QPath>();
/**
* Usecase of Workspace.restore(Version[], boolean), for not existing
* versionable nodes in the target workspace.
*/
protected final SessionChangesLog delegatedChanges;
private NodeTypeDataManager nodeTypeDataManager;
protected class NodeDataContext
{
private final NodeData node;
private final boolean existing;
protected NodeDataContext(NodeData node)
{
this.node = node;
this.existing = false;
}
protected NodeDataContext(NodeData node, boolean existing)
{
this.node = node;
this.existing = existing;
}
protected NodeData getNode()
{
return this.node;
}
public boolean isExisting()
{
return existing;
}
}
/**
* Prepare item states for removing subtree before restoring. Accordingly to JCR specification
* some nodes will remain and not be deleted. For this case visitor skips such nodes and stores
* its paths. For nodes with OnParentVersion attribute IGNORE ItemDataCopyIgnoredVisitor will be used
* to copy children/properties to the restored node.
*/
protected class RemoveVisitor extends ItemDataRemoveVisitor
{
/**
* The stack. In the top it contains a parent node.
*/
protected Stack<NodeData> parents = new Stack<NodeData>();
/**
* Last met node path during traversing which will remain during restore and not be deleted.
*/
private QPath remainedNode;
/**
* Node path for updating instead of deleting. All ancestors of remained nodes
* not be deleted since updating will be applied later.
*/
private final Set<QPath> updatingPath = new HashSet<QPath>();
/**
* RemoveVisitor constructor.
*
* @throws RepositoryException
*/
RemoveVisitor() throws RepositoryException
{
super(userSession.getTransientNodesManager(), null, nodeTypeDataManager, userSession.getAccessManager(),
userSession.getUserState());
}
/**
* {@inheritDoc}
*/
@Override
protected void validateReferential(NodeData node) throws RepositoryException
{
// no REFERENCE validation here
}
/**
* {@inheritDoc}
*/
@Override
protected void entering(NodeData node, int level) throws RepositoryException
{
if (level == 0)
{
removedRoot = node;
}
parents.push(node);
}
/**
* {@inheritDoc}
*/
@Override
public void visit(NodeData node) throws RepositoryException
{
if (currentLevel > 0)
{
NodeData parent = parents.peek();
int onParentVersion =
nodeTypeDataManager.getChildNodeDefinition(node.getQPath().getName(), node.getPrimaryTypeName(),
parent.getPrimaryTypeName(), parent.getMixinTypeNames()).getOnParentVersion();
if (onParentVersion == OnParentVersionAction.VERSION
&& nodeTypeDataManager.isNodeType(Constants.MIX_VERSIONABLE, node.getPrimaryTypeName(),
node.getMixinTypeNames()))
{
remainedNode = node.getQPath();
// node and its children will remain and not be removed
return;
}
}
super.visit(node);
}
/**
* {@inheritDoc}
*/
@Override
protected void leaving(NodeData node, int level) throws RepositoryException
{
if (validate)
{
validate(node);
}
if (remainedNode != null && remainedNode.isDescendantOf(node.getQPath()))
{
updatingPath.add(node.getQPath());
}
else
{
if (!(node instanceof TransientItemData))
{
node = (NodeData)copyItemDataDelete(node);
}
ItemState state =
new ItemState(node, ItemState.DELETED, true, ancestorToSave != null ? ancestorToSave
: removedRoot.getQPath());
itemRemovedStates.add(state);
}
parents.pop();
}
/**
* {@inheritDoc}
*/
@Override
public List<ItemState> getRemovedStates()
{
return itemRemovedStates;
}
/**
* Return nodes paths for updating.
*
* @return Set
*/
public Set<QPath> getUpdatingPath()
{
return updatingPath;
}
};
ItemDataRestoreVisitor(NodeData context, InternalQName restoringName, NodeData history, SessionImpl userSession,
boolean removeExisting) throws RepositoryException
{
this(context, restoringName, history, userSession, removeExisting, null);
}
ItemDataRestoreVisitor(NodeData context, InternalQName destName, NodeData history, SessionImpl userSession,
boolean removeExisting, SessionChangesLog delegatedChanges) throws RepositoryException
{
super(userSession.getTransientNodesManager().getTransactManager());
this.userSession = userSession;
this.changes = new SessionChangesLog(userSession);
this.context = context;
this.destName = destName;
this.history = history;
this.parents.push(new NodeDataContext(context));
this.removeExisting = removeExisting;
this.nodeTypeDataManager = userSession.getWorkspace().getNodeTypesHolder();
this.delegatedChanges = delegatedChanges;
}
private NodeData currentNode()
{
return parents.peek().getNode();
}
private NodeData pushCurrent(NodeData node)
{
return parents.push(new NodeDataContext(node)).getNode();
}
private ItemData findDelegated(String identifier)
{
if (delegatedChanges != null)
{
for (ItemState state : delegatedChanges.getAllStates())
{
if (state.getData().getIdentifier().equals(identifier))
{
return state.getData();
}
}
}
return null;
}
private ItemData findDelegated(QPath path)
{
if (delegatedChanges != null)
{
for (ItemState state : delegatedChanges.getAllStates())
{
if (state.getData().getQPath().equals(path))
{
return state.getData();
}
}
}
return null;
}
private void deleteDelegated(QPath path)
{
if (delegatedChanges != null)
{
List<ItemState> removed = new ArrayList<ItemState>();
for (ItemState state : delegatedChanges.getAllStates())
{
if (state.getData().getQPath().equals(path) || state.getData().getQPath().isDescendantOf(path))
{
removed.add(state);
}
}
for (ItemState state : removed)
{
delegatedChanges.remove(state.getData().getQPath());
}
}
}
protected void initRestoreRoot(NodeData parentData, InternalQName name, NodeData frozen) throws RepositoryException
{
// WARNING: path with index=1
QPath nodePath = QPath.makeChildPath(parentData.getQPath(), name);
if (log.isDebugEnabled())
{
log.debug("Restore: " + nodePath.getAsString() + ", removeExisting=" + removeExisting);
}
PropertyData frozenIdentifier =
(PropertyData)dataManager.getItemData(frozen, new QPathEntry(Constants.JCR_FROZENUUID, 1), ItemType.PROPERTY);
String fidentifier = null;
NodeData existing = null;
// make new node from frozen
try
{
fidentifier = ValueDataUtil.getString(frozenIdentifier.getValues().get(0));
NodeData sameIdentifierNodeRestored = (NodeData)findDelegated(fidentifier);
if (sameIdentifierNodeRestored != null)
{
// already restored from delegated call, remove it as we interested in
// this version state
deleteDelegated(sameIdentifierNodeRestored.getQPath());
}
else
{
NodeData sameIdentifierNode = (NodeData)dataManager.getItemData(fidentifier);
if (sameIdentifierNode != null)
{
QPath sameIdentifierPath = sameIdentifierNode.getQPath();
if (sameIdentifierPath.makeParentPath().equals(nodePath.makeParentPath()) && // same
// parent
sameIdentifierPath.getName().equals(nodePath.getName()))
{ // same
// name
if (sameIdentifierPath.getIndex() != nodePath.getIndex())
{
// but different index, see below... fix it
nodePath = QPath.makeChildPath(parentData.getQPath(), name, sameIdentifierPath.getIndex());
}
// if it's a target node
existing = sameIdentifierNode;
// remove existed node, with validation
RemoveVisitor removeVisitor = new RemoveVisitor();
removeVisitor.visit(existing);
changes.addAll(removeVisitor.getRemovedStates());
updatingPath.addAll(removeVisitor.getUpdatingPath());
}
else if (!sameIdentifierPath.isDescendantOf(nodePath))
{
if (removeExisting)
{
final QPath restorePath = nodePath;
// remove same uuid node, with validation
class RemoveVisitor extends ItemDataRemoveVisitor
{
RemoveVisitor() throws RepositoryException
{
super(userSession.getTransientNodesManager(), null, nodeTypeDataManager, userSession
.getAccessManager(), userSession.getUserState());
}
@Override
protected boolean isRemoveDescendant(ItemData item) throws RepositoryException
{
return item.getQPath().isDescendantOf(removedRoot.getQPath())
|| item.getQPath().isDescendantOf(restorePath);
}
};
ItemDataRemoveVisitor removeVisitor = new RemoveVisitor();
removeVisitor.visit(sameIdentifierNode);
changes.addAll(removeVisitor.getRemovedStates());
}
else
{
throw new ItemExistsException("Item with the same UUID as restored node " + nodePath.getAsString()
+ " already exists and removeExisting=false. Existed "
+ userSession.getLocationFactory().createJCRPath(sameIdentifierPath).getAsString(false) + " "
+ sameIdentifierNode.getIdentifier());
}
}
}
}
}
catch (IllegalStateException e)
{
throw new RepositoryException("jcr:frozenUuid, error of data read "
+ userSession.getLocationFactory().createJCRPath(frozenIdentifier.getQPath()).getAsString(false), e);
}
PropertyData frozenPrimaryType =
(PropertyData)dataManager.getItemData(frozen, new QPathEntry(Constants.JCR_FROZENPRIMARYTYPE, 0),
ItemType.PROPERTY);
PropertyData frozenMixinTypes =
(PropertyData)dataManager.getItemData(frozen, new QPathEntry(Constants.JCR_FROZENMIXINTYPES, 0),
ItemType.PROPERTY);
List<AccessControlEntry> accessList =
new ArrayList<AccessControlEntry>(parentData.getACL().getPermissionEntries());
String owner = parentData.getACL().getOwner();
InternalQName[] mixins = null;
if (frozenMixinTypes != null)
{
try
{
List<ValueData> mvs = frozenMixinTypes.getValues();
mixins = new InternalQName[mvs.size()];
for (int i = 0; i < mvs.size(); i++)
{
ValueData mvd = mvs.get(i);
mixins[i] = InternalQName.parse(ValueDataUtil.getString(mvd));
if (mixins[i].equals(Constants.EXO_PRIVILEGEABLE))
{
PropertyData aclData =
(PropertyData)dataManager.getItemData(frozen, new QPathEntry(Constants.EXO_PERMISSIONS, 0),
ItemType.PROPERTY);
AccessControlList acl = new AccessControlList();
acl.removePermissions(IdentityConstants.ANY);
for (ValueData value : aclData.getValues())
{
acl.addPermissions(ValueDataUtil.getString(value));
}
accessList = acl.getPermissionEntries();
}
else if (mixins[i].equals(Constants.EXO_OWNEABLE))
{
PropertyData ownerData =
(PropertyData)dataManager.getItemData(frozen, new QPathEntry(Constants.EXO_OWNER, 0),
ItemType.PROPERTY);
owner = ValueDataUtil.getString(ownerData.getValues().get(0));
}
}
}
catch (IllegalNameException e)
{
throw new RepositoryException("jcr:frozenMixinTypes, error of data read "
+ userSession.getLocationFactory().createJCRPath(frozenMixinTypes.getQPath()).getAsString(false), e);
}
catch (IllegalStateException e)
{
throw new RepositoryException("jcr:frozenMixinTypes, error of data read "
+ userSession.getLocationFactory().createJCRPath(frozenMixinTypes.getQPath()).getAsString(false), e);
}
}
AccessControlList acl = new AccessControlList(owner, accessList);
InternalQName ptName = null;
try
{
ptName = InternalQName.parse(ValueDataUtil.getString(frozenPrimaryType.getValues().get(0)));
}
catch (IllegalNameException e)
{
throw new RepositoryException("jcr:frozenPrimaryType, error of data read "
+ userSession.getLocationFactory().createJCRPath(frozenPrimaryType.getQPath()).getAsString(false), e);
}
catch (IllegalStateException e)
{
throw new RepositoryException("jcr:frozenPrimaryType, error of data read "
+ userSession.getLocationFactory().createJCRPath(frozenPrimaryType.getQPath()).getAsString(false), e);
}
// create restored version of the node
NodeData restoredData =
new TransientNodeData(nodePath, fidentifier, (existing != null ? existing.getPersistedVersion() : -1), ptName,
mixins == null ? new InternalQName[0] : mixins, 0, parentData.getIdentifier(), acl);
if (updatingPath.contains(nodePath))
{
changes.add(ItemState.createUpdatedState(restoredData));
}
else
{
changes.add(ItemState.createAddedState(restoredData));
}
pushCurrent(restoredData);
}
@Override
protected void entering(NodeData frozen, int level) throws RepositoryException
{
if (frozen == null)
{
return;
}
if (log.isDebugEnabled())
{
log.debug("Visit node " + frozen.getQPath().getAsString() + ", HAS NULL FROZEN NODE");
}
InternalQName qname = frozen.getQPath().getName();
if (qname.equals(Constants.JCR_FROZENNODE) && level == 0)
{
// child props/nodes will be restored
if (log.isDebugEnabled())
{
log.debug("jcr:frozenNode " + frozen.getQPath().getAsString());
}
// init destenation node
initRestoreRoot(currentNode(), destName, frozen);
restored = currentNode();
}
else if (nodeTypeDataManager.isNodeType(Constants.NT_VERSIONEDCHILD, frozen.getPrimaryTypeName()))
{
QPath cvhpPropPath = QPath.makeChildPath(frozen.getQPath(), Constants.JCR_CHILDVERSIONHISTORY);
if (log.isDebugEnabled())
{
log.debug("Versioned child node " + cvhpPropPath.getAsString());
}
VersionHistoryDataHelper childHistory = null;
try
{
String vhIdentifier =
ValueDataUtil.getString(((PropertyData)dataManager.getItemData(frozen, new QPathEntry(
Constants.JCR_CHILDVERSIONHISTORY, 0), ItemType.PROPERTY)).getValues().get(0));
NodeData cHistory = null;
if ((cHistory = (NodeData)dataManager.getItemData(vhIdentifier)) == null)
{
throw new RepositoryException("Version history is not found with uuid " + vhIdentifier);
}
childHistory = new VersionHistoryDataHelper(cHistory, dataManager, nodeTypeDataManager);
}
catch (IllegalStateException e)
{
throw new RepositoryException("jcr:childVersionHistory, error of data read "
+ userSession.getLocationFactory().createJCRPath(cvhpPropPath).getAsString(false), e);
}
String versionableIdentifier =
ValueDataUtil.getString(((PropertyData)dataManager.getItemData(childHistory, new QPathEntry(
Constants.JCR_VERSIONABLEUUID, 0), ItemType.PROPERTY)).getValues().get(0));
NodeData versionable = (NodeData)dataManager.getItemData(versionableIdentifier);
if (versionable != null)
{
// exists,
// On restore of VN, if the workspace currently has an already
// existing node corresponding to C’s version history and the
// removeExisting flag of the restore is set to true, then that
// instance of C becomes the child of the restored N.
if (!removeExisting)
{
throw new JCRItemExistsException("Item with the same UUID " + versionableIdentifier
+ " as versionable child node "
+ userSession.getLocationFactory().createJCRPath(versionable.getQPath()).getAsString(false)
+ " already exists and removeExisting=false", versionableIdentifier);
}
// else - leaving existed unchanged
}
else
{
// not found, gets last version (by time of creation) and restore it
NodeData lastVersionData = childHistory.getLastVersionData();
NodeData cvFrozen =
(NodeData)dataManager.getItemData(lastVersionData, new QPathEntry(Constants.JCR_FROZENNODE, 1),
ItemType.NODE);
ItemDataRestoreVisitor restoreVisitor =
new ItemDataRestoreVisitor(currentNode(), qname, childHistory, userSession, removeExisting, changes);
cvFrozen.accept(restoreVisitor);
changes.addAll(restoreVisitor.getRestoreChanges().getAllStates());
}
pushCurrent(null); // skip any childs of that node
}
else if (currentNode() != null)
{
// ordinary node for copy under nt:frozenNode
// [PN] 10.04.06 In case of COPY - copy node, otherwise we don't
// 8.2.11.3 INITIALIZE; 8.2.11.4 COMPUTE
// On restore of VN, the C stored as its child will be ignored, and the
// current C in the workspace will be left unchanged.
int action =
nodeTypeDataManager.getChildNodeDefinition(qname, frozen.getPrimaryTypeName(),
currentNode().getPrimaryTypeName(),
currentNode().getMixinTypeNames()).getOnParentVersion();
if (log.isDebugEnabled())
{
log.debug("Stored node " + frozen.getQPath().getAsString() + ", "
+ OnParentVersionAction.nameFromValue(action));
}
if (action == OnParentVersionAction.COPY || action == OnParentVersionAction.VERSION)
{
// copy
QPath restoredPath =
QPath.makeChildPath(currentNode().getQPath(), frozen.getQPath().getName(), frozen.getQPath().getIndex());
// jcr:uuid
String jcrUuid = null;
NodeData existing = null;
if (nodeTypeDataManager.isNodeType(Constants.MIX_REFERENCEABLE, frozen.getPrimaryTypeName(),
frozen.getMixinTypeNames()))
{
// copy uuid from frozen state of mix:referenceable,
// NOTE: mix:referenceable stored in frozen state with genereted ID
// (JCR_XITEM PK) as UUID must be unique,
// but jcr:uuid property containts real UUID.
QPath jcrUuidPath = QPath.makeChildPath(frozen.getQPath(), Constants.JCR_UUID);
jcrUuid =
ValueDataUtil.getString(((PropertyData)dataManager.getItemData(frozen, new QPathEntry(
Constants.JCR_UUID, 0), ItemType.PROPERTY)).getValues().get(0));
existing = (NodeData)dataManager.getItemData(jcrUuid);
}
else
{
// try to use existing node uuid, otherwise to generate one new
existing =
(NodeData)dataManager.getItemData(currentNode(), new QPathEntry(frozen.getQPath().getName(), frozen
.getQPath().getIndex()), ItemType.NODE);
if (existing != null)
{
jcrUuid = existing.getIdentifier();
}
else
{
jcrUuid = IdGenerator.generate();
}
}
if (existing != null && !existing.getQPath().isDescendantOf(restored.getQPath()))
{
NodeData existingDelegared = (NodeData)findDelegated(existing.getQPath());
if (existingDelegared != null)
{
// was restored by previous restore (Workspace.restore(...)), remove
// it from delegated log
deleteDelegated(existing.getQPath());
}
else
{
// exists in workspace
if (removeExisting)
{
if (changes.getItemState(existing.getIdentifier(), ItemState.DELETED) == null)
{
// remove existed node, with validation (same as for restored
// root)
RemoveVisitor removeVisitor = new RemoveVisitor();
removeVisitor.visit(existing);
changes.addAll(removeVisitor.getRemovedStates());
updatingPath.addAll(removeVisitor.getUpdatingPath());
}
}
else
{
throw new ItemExistsException("Node with the same UUID as restored child node "
+ userSession.getLocationFactory().createJCRPath(restoredPath).getAsString(false)
+ " already exists and removeExisting=false. Existed "
+ userSession.getLocationFactory().createJCRPath(existing.getQPath()).getAsString(false) + " "
+ existing.getIdentifier());
}
}
}
AccessControlList acl = currentNode().getACL();
boolean isPrivilegeable =
nodeTypeDataManager.isNodeType(Constants.EXO_PRIVILEGEABLE, frozen.getPrimaryTypeName(),
frozen.getMixinTypeNames());
boolean isOwneable =
nodeTypeDataManager.isNodeType(Constants.EXO_OWNEABLE, frozen.getPrimaryTypeName(),
frozen.getMixinTypeNames());
if (isPrivilegeable || isOwneable)
{
List<AccessControlEntry> permissionEntries = new ArrayList<AccessControlEntry>();
permissionEntries.addAll((isPrivilegeable ? frozen.getACL() : currentNode().getACL())
.getPermissionEntries());
String owner = isOwneable ? frozen.getACL().getOwner() : currentNode().getACL().getOwner();
acl = new AccessControlList(owner, permissionEntries);
}
NodeData restoredData =
new TransientNodeData(restoredPath, jcrUuid, frozen.getPersistedVersion(), frozen.getPrimaryTypeName(),
frozen.getMixinTypeNames(), frozen.getOrderNumber(), currentNode().getIdentifier(), acl);
if (updatingPath.contains(restoredPath))
{
changes.add(ItemState.createUpdatedState(restoredData));
}
else
{
changes.add(ItemState.createAddedState(restoredData));
}
pushCurrent(restoredData);
}
else if (action == OnParentVersionAction.INITIALIZE || action == OnParentVersionAction.COMPUTE)
{
// current C in the workspace will be left unchanged,
NodeData existed =
(NodeData)dataManager.getItemData(currentNode(), new QPathEntry(frozen.getQPath().getName(), 0),
ItemType.NODE);
if (existed != null)
{
// copy existed - i.e. left unchanged
ItemDataCopyVisitor copyVisitor =
new ItemDataCopyVisitor(currentNode(), frozen.getQPath().getName(), nodeTypeDataManager,
userSession.getTransientNodesManager(), userSession.getTransientNodesManager(), true);
existed.accept(copyVisitor);
changes.addAll(copyVisitor.getItemAddStates());
} // else - nothing to do, i.e. left unchanged
pushCurrent(null); // JCR-193, skip any childs of that node now
}
}
}
@Override
protected void entering(PropertyData property, int level) throws RepositoryException
{
if (currentNode() != null)
{
NodeData frozenParent = (NodeData)dataManager.getItemData(property.getParentIdentifier());
InternalQName qname = property.getQPath().getName();
if (nodeTypeDataManager.isNodeType(Constants.NT_FROZENNODE, frozenParent.getPrimaryTypeName()))
{
if (qname.equals(Constants.JCR_FROZENPRIMARYTYPE))
{
qname = Constants.JCR_PRIMARYTYPE;
}
else if (qname.equals(Constants.JCR_FROZENUUID))
{
qname = Constants.JCR_UUID;
}
else if (qname.equals(Constants.JCR_FROZENMIXINTYPES))
{
qname = Constants.JCR_MIXINTYPES;
}
else if (qname.equals(Constants.JCR_PRIMARYTYPE) || qname.equals(Constants.JCR_UUID)
|| qname.equals(Constants.JCR_MIXINTYPES))
{
// skip these props, as they are a nt:frozenNode special props
return;
}
}
int action =
nodeTypeDataManager
.getPropertyDefinitions(qname, currentNode().getPrimaryTypeName(), currentNode().getMixinTypeNames())
.getAnyDefinition().getOnParentVersion();
if (log.isDebugEnabled())
{
log.debug("Visit property " + property.getQPath().getAsString() + " "
+ currentNode().getQPath().getAsString() + " " + OnParentVersionAction.nameFromValue(action));
}
if (action == OnParentVersionAction.COPY || action == OnParentVersionAction.VERSION
|| action == OnParentVersionAction.INITIALIZE || action == OnParentVersionAction.COMPUTE)
{
// In case of COPY, VERSION - copy property
PropertyData tagetProperty = null;
if (qname.equals(Constants.JCR_PREDECESSORS))
{
tagetProperty =
TransientPropertyData.createPropertyData(currentNode(), qname, property.getType(),
property.isMultiValued(), new ArrayList<ValueData>());
}
else
{
tagetProperty =
TransientPropertyData.createPropertyData(currentNode(), qname, property.getType(),
property.isMultiValued(), copyValues(property));
}
changes.add(ItemState.createAddedState(tagetProperty));
}
else if (log.isDebugEnabled())
{
// else - nothing to do, i.e. left unchanged
log.debug("Visit property " + property.getQPath().getAsString() + " HAS "
+ OnParentVersionAction.nameFromValue(action) + " action");
}
}
else if (log.isDebugEnabled())
{
log.debug("Visit property " + property.getQPath().getAsString()
+ " HAS NULL PARENT. Restore of this property is impossible.");
}
}
@Override
protected void leaving(NodeData frozen, int level) throws RepositoryException
{
InternalQName qname = frozen.getQPath().getName();
if (qname.equals(Constants.JCR_FROZENNODE) && level == 0)
{
if (log.isDebugEnabled())
{
log.debug("leaving jcr:frozenNode " + frozen.getQPath().getAsString());
}
// post init of a restored node
PropertyData baseVersion =
TransientPropertyData.createPropertyData(restored, Constants.JCR_BASEVERSION, PropertyType.REFERENCE,
false, new TransientValueData(new Identifier(frozen.getParentIdentifier())));
PropertyData isCheckedOut =
TransientPropertyData.createPropertyData(restored, Constants.JCR_ISCHECKEDOUT, PropertyType.BOOLEAN, false,
new TransientValueData(false));
NodeData existing = (NodeData)dataManager.getItemData(restored.getIdentifier());
if (existing != null && !existing.getQPath().isDescendantOf(Constants.JCR_VERSION_STORAGE_PATH))
{
// copy childs/properties with OnParentVersionAction.IGNORE to the
// restored node
ItemDataCopyIgnoredVisitor copyIgnoredVisitor =
new ItemDataCopyIgnoredVisitor((NodeData)dataManager.getItemData(restored.getParentIdentifier()),
restored.getQPath().getName(), nodeTypeDataManager, userSession.getTransientNodesManager(), changes);
existing.accept(copyIgnoredVisitor);
changes.addAll(copyIgnoredVisitor.getItemAddStates());
}
changes.add(ItemState.createAddedState(baseVersion));
changes.add(ItemState.createAddedState(isCheckedOut));
}
if (parents.size() <= 0)
{
log.error("Empty parents stack");
}
parents.pop();
}
@Override
protected void leaving(PropertyData property, int level) throws RepositoryException
{
}
public SessionChangesLog getRestoreChanges()
{
return changes;
}
public NodeData getRestoreRoot()
{
return restored;
}
}