runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java

   1 package org.argeo.slc.jcr.execution;
   2
   3 import java.util.Collections;
   4 import java.util.GregorianCalendar;
   5 import java.util.HashMap;
   6 import java.util.Map;
   7
   8 import javax.jcr.Node;
   9 import javax.jcr.Property;
  10 import javax.jcr.RepositoryException;
  11 import javax.jcr.Session;
  12 import javax.jcr.query.Query;
  13
  14 import org.apache.commons.logging.Log;
  15 import org.apache.commons.logging.LogFactory;
  16 import org.argeo.jcr.JcrUtils;
  17 import org.argeo.slc.core.attachment.Attachment;
  18 import org.argeo.slc.core.structure.tree.TreeSPath;
  19 import org.argeo.slc.core.test.tree.TreeTestResult;
  20 import org.argeo.slc.core.test.tree.TreeTestResultListener;
  21 import org.argeo.slc.jcr.SlcJcrUtils;
  22 import org.argeo.slc.jcr.SlcNames;
  23 import org.argeo.slc.jcr.SlcTypes;
  24 import org.argeo.slc.test.TestResultPart;
  25 import org.argeo.slc.test.TestStatus;
  26
  27 /** Persists results in JCR */
  28 public class JcrResultListener implements TreeTestResultListener, SlcNames {
  29         private final static Log log = LogFactory.getLog(JcrResultListener.class);
  30
  31         private Session session;
  32
  33         /** Caches the mapping between SLC uuids and internal JCR identifiers */
  34         private Map<String, String> uuidToIdentifier = Collections
  35                         .synchronizedMap(new HashMap<String, String>());
  36
  37         public void resultPartAdded(TreeTestResult testResult,
  38                         TestResultPart testResultPart) {
  39                 try {
  40                         String uuid = testResult.getUuid();
  41                         Node resultNode = getResultNode(uuid);
  42                         if (resultNode == null) {
  43                                 resultNode = createResultNode(testResult);
  44                                 // session.save();
  45                         }
  46                         String partParentPath;
  47                         TreeSPath currentPath = testResult.getCurrentPath();
  48                         if (currentPath != null) {
  49                                 String subPath = currentPath.getAsUniqueString();
  50                                 partParentPath = resultNode.getPath() + subPath;
  51                         } else {
  52                                 partParentPath = resultNode.getPath();
  53                                 // TODO create some depth?
  54                         }
  55
  56                         Node partParentNode;
  57                         if (session.itemExists(partParentPath)) {
  58                                 partParentNode = session.getNode(partParentPath);
  59                         } else {
  60                                 partParentNode = JcrUtils.mkdirs(session, partParentPath);
  61                                 // session.save();
  62                         }
  63                         // create part node
  64                         // TODO find a better name
  65                         String partNodeName = Long.toString(System.currentTimeMillis());
  66                         Node resultPartNode = partParentNode.addNode(partNodeName,
  67                                         SlcTypes.SLC_CHECK);
  68                         resultPartNode.setProperty(SLC_SUCCESS,
  69                                         testResultPart.getStatus() == TestStatus.PASSED);
  70                         if (testResultPart.getMessage() != null)
  71                                 resultPartNode.setProperty(SLC_MESSAGE,
  72                                                 testResultPart.getMessage());
  73                         if (testResultPart.getExceptionMessage() != null)
  74                                 resultPartNode.setProperty(SLC_ERROR_MESSAGE,
  75                                                 testResultPart.getExceptionMessage());
  76                         // JcrUtils.debug(resultPartNode);
  77
  78                         JcrUtils.updateLastModified(resultNode);
  79
  80                         session.save();
  81                 } catch (RepositoryException e) {
  82                         JcrUtils.discardQuietly(session);
  83                         log.error("Cannot add result part " + testResultPart + " to "
  84                                         + testResult, e);
  85                         // throw new SlcException("Cannot add result part " + testResultPart
  86                         // + " to " + testResult, e);
  87                 }
  88
  89         }
  90
  91         /** @return null if does not exist */
  92         protected Node getResultNode(String uuid) throws RepositoryException {
  93                 Node resultNode;
  94                 if (uuidToIdentifier.containsKey(uuid)) {
  95                         return session.getNodeByIdentifier(uuidToIdentifier.get(uuid));
  96                 } else {
  97                         Query q = session
  98                                         .getWorkspace()
  99                                         .getQueryManager()
 100                                         .createQuery(
 101                                                         "select * from [slc:result] where [slc:uuid]='"
 102                                                                         + uuid + "'", Query.JCR_SQL2);
 103                         resultNode = JcrUtils.querySingleNode(q);
 104                         if (resultNode != null)
 105                                 uuidToIdentifier.put(uuid, resultNode.getIdentifier());
 106                 }
 107                 return resultNode;
 108         }
 109
 110         protected Node createResultNode(TreeTestResult testResult)
 111                         throws RepositoryException {
 112                 String uuid = testResult.getUuid();
 113                 String path = SlcJcrUtils.createResultPath(uuid);
 114                 Node resultNode = JcrUtils.mkdirs(session, path, SlcTypes.SLC_RESULT);
 115                 resultNode.setProperty(SLC_UUID, uuid);
 116                 for (Map.Entry<String, String> entry : testResult.getAttributes()
 117                                 .entrySet()) {
 118                         resultNode.setProperty(entry.getKey(), entry.getValue());
 119                 }
 120
 121                 uuidToIdentifier.put(uuid, resultNode.getIdentifier());
 122                 return resultNode;
 123         }
 124
 125         public void close(TreeTestResult testResult) {
 126                 try {
 127                         String uuid = testResult.getUuid();
 128                         Node resultNode = getResultNode(uuid);
 129                         if (resultNode == null)
 130                                 resultNode = createResultNode(testResult);
 131                         JcrUtils.updateLastModified(resultNode);
 132                         GregorianCalendar closeDate = new GregorianCalendar();
 133                         closeDate.setTime(testResult.getCloseDate());
 134                         resultNode.setProperty(SLC_COMPLETED, closeDate);
 135
 136                         uuidToIdentifier.remove(uuid);
 137                         session.save();
 138                 } catch (RepositoryException e) {
 139                         JcrUtils.discardQuietly(session);
 140                         log.error("Cannot close result " + testResult, e);
 141                         // throw new SlcException("Cannot close result " + testResult, e);
 142                 }
 143
 144         }
 145
 146         public void addAttachment(TreeTestResult testResult, Attachment attachment) {
 147
 148         }
 149
 150         public void setSession(Session session) {
 151                 this.session = session;
 152         }
 153
 154 }