Fix repo sync

[gpl/argeo-slc.git] / runtime / org.argeo.slc.repo / src / main / java / org / argeo / slc / repo / RepoSync.java

diff --git a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/RepoSync.java b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/RepoSync.java
index 7c2867754abe9eae0ab2ce2d96016f19349106e3..d145eb225202a045b701b4777b8e7b470b65de27 100644 (file)
--- a/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/RepoSync.java
+++ b/runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/RepoSync.java
@@ -129,12 +129,11 @@ public class RepoSync implements Runnable {
                                                targetPassword);
                        targetDefaultSession = targetRepository.login(targetCredentials);
 
-                       // FIXME implement a cleaner way to compute job size.
-                       // Compute job size
-
                        Map<String, Exception> errors = new HashMap<String, Exception>();
                        for (String sourceWorkspaceName : sourceDefaultSession
                                        .getWorkspace().getAccessibleWorkspaceNames()) {
+                               if (monitor != null && monitor.isCanceled())
+                                       break;
 
                                if (sourceWkspList != null
                                                && !sourceWkspList.contains(sourceWorkspaceName))
@@ -249,7 +248,7 @@ public class RepoSync implements Runnable {
                                        Node node = it.nextNode();
                                        if (node.getName().equals("jcr:system"))
                                                continue;
-                                       syncNode(node, targetSession, true);
+                                       syncNode(node, targetSession);
                                }
                        }
                        if (log.isDebugEnabled())
@@ -266,9 +265,9 @@ public class RepoSync implements Runnable {
                updateMonitor(msg, false);
        }
 
-       protected void syncNode(Node sourceNode, Session targetSession,
-                       Boolean doSave) throws RepositoryException, SAXException {
-               Boolean singleLevel = singleLevel(sourceNode);
+       protected void syncNode(Node sourceNode, Session targetSession)
+                       throws RepositoryException, SAXException {
+               // Boolean singleLevel = singleLevel(sourceNode);
 
                if (monitor != null && monitor.isCanceled()) {
                        updateMonitor("Fetched has been canceled, "
@@ -279,60 +278,64 @@ public class RepoSync implements Runnable {
                Node targetParentNode = targetSession.getNode(sourceNode.getParent()
                                .getPath());
                Node targetNode;
-               final Boolean isNew;
-               if (monitor != null && sourceNode.isNodeType(NodeType.NT_FILE))
+               if (monitor != null
+                               && sourceNode.isNodeType(NodeType.NT_HIERARCHY_NODE))
                        monitor.subTask("Process " + sourceNode.getPath());
+
+               final Boolean isNew;
                if (!targetSession.itemExists(sourceNode.getPath())) {
                        isNew = true;
-                       // updateMonitor("Adding " + sourceNode.getPath());
                        targetNode = targetParentNode.addNode(sourceNode.getName(),
                                        sourceNode.getPrimaryNodeType().getName());
                } else {
                        isNew = false;
-                       // updateMonitor("Updating " + sourceNode.getPath());
                        targetNode = targetSession.getNode(sourceNode.getPath());
                        if (!targetNode.getPrimaryNodeType().getName()
                                        .equals(sourceNode.getPrimaryNodeType().getName()))
                                targetNode.setPrimaryType(sourceNode.getPrimaryNodeType()
                                                .getName());
                }
-               for (NodeType nt : sourceNode.getMixinNodeTypes()) {
-                       if (!targetNode.isNodeType(nt.getName())
-                                       && targetNode.canAddMixin(nt.getName()))
-                               targetNode.addMixin(nt.getName());
-               }
 
                // export
                // sourceNode.getSession().exportSystemView(sourceNode.getPath(),
                // contentHandler, false, singleLevel);
-               copyProperties(sourceNode, targetSession, singleLevel);
 
-               if (singleLevel) {
-                       if (targetSession.hasPendingChanges()) {
-                               // updateMonitor(
-                               // (isNew ? "Added " : "Updated ") + targetNode.getPath(),
-                               // true);
-                               if (doSave)
-                                       targetSession.save();
-                       } else {
-                               // updateMonitor("Checked " + targetNode.getPath(), false);
-                       }
+               // if (singleLevel) {
+               // if (targetSession.hasPendingChanges()) {
+               // // updateMonitor(
+               // // (isNew ? "Added " : "Updated ") + targetNode.getPath(),
+               // // true);
+               // if (doSave)
+               // targetSession.save();
+               // } else {
+               // // updateMonitor("Checked " + targetNode.getPath(), false);
+               // }
+               // }
+
+               // mixin and properties
+               for (NodeType nt : sourceNode.getMixinNodeTypes()) {
+                       if (!targetNode.isNodeType(nt.getName())
+                                       && targetNode.canAddMixin(nt.getName()))
+                               targetNode.addMixin(nt.getName());
                }
+               copyProperties(sourceNode, targetNode);
 
                // next level
                for (NodeIterator ni = sourceNode.getNodes(); ni.hasNext();) {
                        Node sourceChild = ni.nextNode();
-                       syncNode(sourceChild, targetSession, doSave && singleLevel);
+                       syncNode(sourceChild, targetSession);
                }
 
-               if (!singleLevel) {
+               copyTimestamps(sourceNode, targetNode);
+
+               if (sourceNode.isNodeType(NodeType.NT_HIERARCHY_NODE)) {
                        if (targetSession.hasPendingChanges()) {
                                if (sourceNode.isNodeType(NodeType.NT_FILE))
                                        updateMonitor(
                                                        (isNew ? "Added " : "Updated ")
                                                                        + targetNode.getPath(), true);
-                               if (doSave)
-                                       targetSession.save();
+                               // if (doSave)
+                               targetSession.save();
                        } else {
                                if (sourceNode.isNodeType(NodeType.NT_FILE))
                                        updateMonitor("Checked " + targetNode.getPath(), false);
@@ -340,14 +343,48 @@ public class RepoSync implements Runnable {
                }
        }
 
-       private void copyProperties(Node sourceNode, Session targetSession,
-                       boolean singleLevel) throws RepositoryException {
-               Node targetNode = targetSession.getNode(sourceNode.getPath());
+       private void copyTimestamps(Node sourceNode, Node targetNode)
+                       throws RepositoryException {
+               if (sourceNode.getDefinition().isProtected())
+                       return;
+               if (targetNode.getDefinition().isProtected())
+                       return;
+               copyTimestamp(sourceNode, targetNode, Property.JCR_CREATED);
+               copyTimestamp(sourceNode, targetNode, Property.JCR_CREATED_BY);
+               copyTimestamp(sourceNode, targetNode, Property.JCR_LAST_MODIFIED);
+               copyTimestamp(sourceNode, targetNode, Property.JCR_LAST_MODIFIED_BY);
+       }
+
+       private void copyTimestamp(Node sourceNode, Node targetNode, String property)
+                       throws RepositoryException {
+               if (sourceNode.hasProperty(property)) {
+                       Property p = sourceNode.getProperty(property);
+                       if (p.getDefinition().isProtected())
+                               return;
+                       if (targetNode.hasProperty(property)
+                                       && targetNode
+                                                       .getProperty(property)
+                                                       .getValue()
+                                                       .equals(sourceNode.getProperty(property).getValue()))
+                               return;
+                       targetNode.setProperty(property, sourceNode.getProperty(property)
+                                       .getValue());
+               }
+       }
+
+       private void copyProperties(Node sourceNode, Node targetNode)
+                       throws RepositoryException {
                properties: for (PropertyIterator pi = sourceNode.getProperties(); pi
                                .hasNext();) {
                        Property p = pi.nextProperty();
                        if (p.getDefinition().isProtected())
                                continue properties;
+                       if (p.getName().equals(Property.JCR_CREATED)
+                                       || p.getName().equals(Property.JCR_CREATED_BY)
+                                       || p.getName().equals(Property.JCR_LAST_MODIFIED)
+                                       || p.getName().equals(Property.JCR_LAST_MODIFIED_BY))
+                               continue properties;
+
                        if (p.getType() == PropertyType.BINARY) {
                                copyBinary(p, targetNode);
                        } else {