--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src/main/java"/>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.argeo.slc.client.core</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
--- /dev/null
+#Tue Sep 28 09:36:19 CEST 2010
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
--- /dev/null
+#Wed Sep 22 12:21:25 CEST 2010
+eclipse.preferences.version=1
+pluginProject.extensions=false
+resolve.requirebundle=false
--- /dev/null
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Core
+Bundle-SymbolicName: org.argeo.slc.client.core
+Bundle-Version: 1.0.0.qualifier
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Export-Package: org.argeo.slc.client.aspects,
+ org.argeo.slc.client.contentprovider
+Require-Bundle: org.springframework.orm;bundle-version="2.5.6",
+ org.eclipse.ui;resolution:=optional
+Import-Package: org.apache.commons.io;version="1.4.0",
+ org.apache.commons.logging;version="1.1.1",
+ org.argeo.eclipse.spring,
+ org.argeo.eclipse.ui,
+ org.argeo.slc.client.ui,
+ org.argeo.slc.core.structure.tree,
+ org.argeo.slc.core.test.tree,
+ org.argeo.slc.dao.process,
+ org.argeo.slc.dao.test.tree,
+ org.argeo.slc.process,
+ org.argeo.slc.test,
+ org.aspectj.lang,
+ org.aspectj.lang.annotation,
+ org.hibernate,
+ org.hibernate.classic,
+ org.springframework.beans.factory;version="2.5.6.SEC01",
+ org.springframework.transaction;version="2.5.6.SEC01"
+
+
--- /dev/null
+source.. = src/main/java/
+output.. = target/classes/
+bin.includes = META-INF/,\
+ .
--- /dev/null
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.argeo.slc.eclipse</groupId>
+ <artifactId>plugins</artifactId>
+ <version>0.13.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.argeo.slc.client.core</artifactId>
+ <name>SLC Client core</name>
+ <packaging>jar</packaging>
+ <dependencies>
+
+ <!-- SLC Client UI -->
+ <dependency>
+ <groupId>org.argeo.slc.eclipse</groupId>
+ <artifactId>org.argeo.slc.client.commons</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <!-- SLC -->
+ <dependency>
+ <groupId>org.argeo.slc.runtime</groupId>
+ <artifactId>org.argeo.slc.core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <!-- Commons -->
+ <dependency>
+ <groupId>org.argeo.commons.eclipse</groupId>
+ <artifactId>org.argeo.eclipse.ui</artifactId>
+ <version>${version.argeo-commons}</version>
+ </dependency>
+ <!-- Spring -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>org.springframework.context</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>org.springframework.transaction</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>org.springframework.orm</artifactId>
+ </dependency>
+ <!-- Eclipse -->
+ <dependency>
+ <groupId>org.eclipse.ui</groupId>
+ <artifactId>org.eclipse.ui</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.core</groupId>
+ <artifactId>org.eclipse.core.runtime</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.swt</groupId>
+ <artifactId>org.eclipse.swt.gtk.linux.x86_64</artifactId>
+ </dependency>
+ <!-- hibernate -->
+ <dependency>
+ <groupId>org.hibernate</groupId>
+ <artifactId>com.springsource.org.hibernate</artifactId>
+ </dependency>
+ <!-- AspectJ -->
+ <dependency>
+ <groupId>org.aspectj</groupId>
+ <artifactId>com.springsource.org.aspectj.runtime</artifactId>
+ </dependency>
+ </dependencies>
+</project>
--- /dev/null
+package org.argeo.slc.client.aspects;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.hibernate.LockMode;
+import org.hibernate.SessionFactory;
+
+/**
+ * Intercepts all calls to get methods of the
+ * org.argeo.slc.client.contentprovider package to insure that objects that are
+ * to be rendered in views are correctly linked to the hibernate session.
+ *
+ * @author bsinou
+ *
+ */
+
+@Aspect
+public class ContentProviderAspect {
+
+ // private final static Log log = LogFactory
+ // .getLog(ContentProviderAspect.class);
+
+ private SessionFactory sessionFactory;
+
+ // We select here only getters from classes of the contentprovider package
+ // that need to get data from hibernate
+
+ // PointCuts
+ @Pointcut("(execution (* org.argeo.slc.client.contentprovider.ProcessListTableLabelProvider.get*(..)) && args(o,..))"
+ + " || (execution (* org.argeo.slc.client.contentprovider.ProcessDetailContentProvider.get*(..)) && args(o,..))"
+ + " || (execution (* org.argeo.slc.client.contentprovider.ResultDetailContentProvider.getElements(..)) && args(o,..))")
+ void contentProviderGetterWrapper(Object o) {
+ }
+
+ // Advices
+ @Around("contentProviderGetterWrapper(o)")
+ public Object aroundGetWrapper(ProceedingJoinPoint thisJoinPoint, Object o)
+ throws Throwable {
+
+ // if (o instanceof ViewSite) {
+ // return thisJoinPoint.proceed();
+ // }
+
+ // TODO : find a mean to handle session & manager with txManager
+ // in order to not have to re-begin a transaction here.
+ sessionFactory.getCurrentSession().beginTransaction();
+
+ // reassociate a transient instance with a session (LockMode.NONE).
+ sessionFactory.getCurrentSession().lock(o, LockMode.NONE);
+
+ Object result = thisJoinPoint.proceed();
+ sessionFactory.getCurrentSession().getTransaction().commit();
+ return result;
+ }
+
+ // IoC
+ public void setSessionFactory(SessionFactory sessionFactory) {
+ this.sessionFactory = sessionFactory;
+ }
+}
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.process.RealizedFlow;
+import org.argeo.slc.process.SlcExecution;
+import org.argeo.slc.process.SlcExecutionStep;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/**
+ * Basic tree view of the chosen process details. For now, only a basic list of
+ * details is displayed, not a tree.
+ */
+public class ProcessDetailContentProvider implements ITreeContentProvider {
+ private final static Log log = LogFactory
+ .getLog(ProcessDetailContentProvider.class);
+
+ private SlcExecution slcExecution;
+
+ // private List<SlcAgent> slcAgents;
+
+ public Object[] getChildren(Object parent) {
+ if (parent instanceof SlcExecution) {
+ slcExecution = (SlcExecution) parent;
+
+ List<SlcExecutionStep> steps = slcExecution.getSteps();
+ List<RealizedFlow> realizedFlows = slcExecution.getRealizedFlows();
+
+ for (int i = 0; i < steps.size(); i++) {
+ log.debug("step[" + i + "] : " + steps.get(i).getType());
+ }
+ for (int i = 0; i < realizedFlows.size(); i++) {
+ log.debug("step[" + i + "] : "
+ + realizedFlows.get(i).toString());
+ }
+
+ log.debug(" Realized flows : ");
+ return steps.toArray();
+ }
+ // if (parent instanceof ExecutionModuleNode) {
+ // ExecutionModuleNode executionModuleNode = (ExecutionModuleNode)
+ // parent;
+ // ExecutionModuleDescriptor emd =
+ // executionModuleNode.getDescriptor();
+ // emd = executionModuleNode.getAgentNode().getAgent()
+ // .getExecutionModuleDescriptor(emd.getName(),
+ // emd.getVersion());
+ // executionModuleNode.cacheDescriptor(emd);
+ // // for (String flowName :
+ // executionModuleNode.getFlowDescriptors()
+ // // .keySet()) {
+ // // executionModuleNode.addChild(new FlowNode(flowName,
+ // // executionModuleNode));
+ // // }
+ // return executionModuleNode.getChildren();
+ // } else if (parent instanceof AgentNode) {
+ // AgentNode agentNode = (AgentNode) parent;
+ //
+ // if (log.isTraceEnabled())
+ // log.trace("Scan agent " + agentNode);
+ //
+ // agentNode.clearChildren();
+ // for (ExecutionModuleDescriptor desc : agentNode.getAgent()
+ // .listExecutionModuleDescriptors()) {
+ // agentNode.addChild(new ExecutionModuleNode(agentNode, desc));
+ // }
+ //
+ // return agentNode.getChildren();
+ // } else if (parent instanceof TreeParent) {
+ // return ((TreeParent) parent).getChildren();
+ // } else if (parent instanceof FlowNode) {
+ // return new Object[0];
+ // } else {
+ // List<AgentNode> agentNodes = new ArrayList<AgentNode>();
+ // for (SlcAgent slcAgent : slcAgents) {
+ // agentNodes.add(new AgentNode(slcAgent));
+ // }
+ // return agentNodes.toArray();
+ // }
+ return null;
+ }
+
+ public Object getParent(Object node) {
+ // if (node instanceof TreeObject) {
+ // return ((TreeObject) node).getParent();
+ // }
+ return null;
+ }
+
+ public boolean hasChildren(Object parent) {
+ return false;
+ }
+
+ public void inputChanged(Viewer v, Object oldInput, Object newInput) {
+ }
+
+ public void dispose() {
+ }
+
+ public Object[] getElements(Object parent) {
+ // return getChildren(parent);
+ // Here we must duplicate the code otherwise the inner call to method
+ // getChildren(parent); is not intercepted by AspectJ
+ if (parent instanceof SlcExecution) {
+ slcExecution = (SlcExecution) parent;
+
+ List<SlcExecutionStep> steps = slcExecution.getSteps();
+ List<RealizedFlow> realizedFlows = slcExecution.getRealizedFlows();
+
+ for (int i = 0; i < steps.size(); i++) {
+ log.debug("step[" + i + "] : " + steps.get(i).getType());
+ }
+ for (int i = 0; i < realizedFlows.size(); i++) {
+ log.debug("step[" + i + "] : "
+ + realizedFlows.get(i).toString());
+ }
+
+ log.debug(" Realized flows : ");
+ return steps.toArray();
+ }
+ return null;
+ }
+}
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import java.util.List;
+
+import org.argeo.slc.process.SlcExecution;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/**
+ * @author bsinou
+ *
+ * Fill ProcessList view. Deported in an external bundle so that main
+ * slc ui bundle does not depend on DB implementation.
+ */
+public class ProcessListStructuredContentProvider implements
+ IStructuredContentProvider {
+
+ public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
+ }
+
+ public void dispose() {
+ }
+
+ @SuppressWarnings("unchecked")
+ public Object[] getElements(Object obj) {
+ if (obj instanceof List) {
+ return ((List<SlcExecution>) obj).toArray();
+ } else {
+ return new Object[0];
+ }
+ }
+
+ public String getColumnText(Object obj, int index) {
+ return null;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import org.argeo.slc.process.SlcExecution;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * @author bsinou
+ *
+ * Fill ProcessList view. Deported in an external bundle so that main
+ * slc ui bundle does not depend on DB implementation.
+ */
+public class ProcessListTableLabelProvider extends LabelProvider implements
+ ITableLabelProvider {
+ public String getColumnText(Object obj, int index) {
+ // log.debug(sessionFactory.getClass().toString());
+
+ SlcExecution se = (SlcExecution) obj;
+ switch (index) {
+
+ case 0:
+ return getText(se.getStartDate());
+ case 1:
+ return se.getHost();
+ case 2:
+ return se.getUuid();
+ case 3:
+ return se.currentStep().getType();
+ }
+ return getText(obj);
+ }
+
+ public Image getColumnImage(Object obj, int index) {
+ return null;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import java.util.List;
+import java.util.SortedMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.eclipse.ui.TreeObject;
+import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.core.structure.tree.TreeSPath;
+import org.argeo.slc.core.test.tree.PartSubList;
+import org.argeo.slc.core.test.tree.TreeTestResult;
+import org.argeo.slc.test.TestResultPart;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/**
+ * Basic tree view of the chosen process details
+ */
+public class ResultDetailContentProvider implements ITreeContentProvider {
+ private final static Log log = LogFactory
+ .getLog(ResultDetailContentProvider.class);
+
+ private TreeTestResult treeTestResult;
+
+ public Object[] getChildren(Object parent) {
+ if (parent instanceof TreeTestResult) {
+ log.error("We should not reach this point.");
+ return null;
+ }
+
+ if (parent instanceof TreeParent) {
+ return ((TreeParent) parent).getChildren();
+ }
+
+ if (parent instanceof ResultPartNode) {
+ // we reached a leaf
+ return null;
+ }
+ return null;
+ }
+
+ public Object getParent(Object node) {
+ if (node instanceof TreeObject) {
+ return ((TreeObject) node).getParent();
+ }
+ return null;
+ }
+
+ public boolean hasChildren(Object parent) {
+ if (parent instanceof TreeParent && ((TreeParent) parent).isLoaded()) {
+ return ((TreeParent) parent).hasChildren();
+ }
+ return false;
+ }
+
+ public void inputChanged(Viewer v, Object oldInput, Object newInput) {
+ }
+
+ public void dispose() {
+ }
+
+ public Object[] getElements(Object parent) {
+ if (parent instanceof TreeTestResult) {
+ treeTestResult = (TreeTestResult) parent;
+
+ // We wrap domain object in ViewSpecificObjects.
+ ResultTreeParent root = new ResultTreeParent("Test "
+ + treeTestResult.getUuid());
+ SortedMap<TreeSPath, PartSubList> partSubLists = treeTestResult
+ .getResultParts();
+
+ for (TreeSPath key : partSubLists.keySet()) {
+ String relPath = key.getAsUniqueString();
+
+ // get rid of '/' that begins every TreeSPath Unique string
+ relPath = relPath.substring(1);
+ String[] pathes = relPath.split("/"); // parse the TreeSPath
+ ResultTreeParent curTreeParent = root;
+
+ // We create intermediate folders if needed
+ for (int i = 0; i < pathes.length; i++) {
+ if (log.isDebugEnabled())
+ log.debug("i = " + i + " - " + pathes[i]);
+
+ if (curTreeParent.getChildByName(pathes[i]) == null) {
+ ResultTreeParent child = new ResultTreeParent(pathes[i]);
+ curTreeParent.addChild(child);
+ curTreeParent = child;
+ } else
+ curTreeParent = (ResultTreeParent) curTreeParent
+ .getChildByName(pathes[i]);
+ }
+
+ // We create leafs
+ List<TestResultPart> parts = partSubLists.get(key).getParts();
+ for (TestResultPart part : parts) {
+ ResultPartNode node = new ResultPartNode(part.toString(),
+ part.getStatus(), part.getMessage(),
+ part.getExceptionMessage());
+ curTreeParent.addChild(node);
+ }
+ }
+
+ // We must set status isPassed for each node.
+ setIsPassed(root);
+ return root.getChildren();
+ }
+ return null;
+ }
+
+ public void setIsPassed(StatusAware node) {
+
+ if (node instanceof ResultTreeObject) {
+ ResultTreeObject rto = (ResultTreeObject) node;
+ rto.isPassed = rto.isPassed();
+ return;
+ }
+ if (node instanceof ResultTreeParent) {
+ ResultTreeParent rtp = (ResultTreeParent) node;
+ // we dig the tree recursivly
+ for (TreeObject to : rtp.getChildren())
+ setIsPassed((StatusAware) to);
+ // we set is passed
+ for (TreeObject to : rtp.getChildren()) {
+ if (!((StatusAware) to).isPassed()) {
+ rtp.isPassed = false;
+ return;
+ }
+ }
+ return;
+ }
+ }
+
+ // To enable display of color to show if a test is passed or not even when
+ // hidden. We say a test is in error if its status is FAILED or ERROR (e.g,
+ // if it has not executed completely due to technical problems).
+ public interface StatusAware {
+ public void setPassed(boolean isPassed);
+
+ public boolean isPassed();
+ }
+
+ public class ResultTreeParent extends TreeParent implements StatusAware {
+
+ public ResultTreeParent(String name) {
+ super(name);
+ }
+
+ private boolean isPassed = true;
+
+ public void setPassed(boolean isPassed) {
+ this.isPassed = isPassed;
+ }
+
+ public boolean isPassed() {
+ return isPassed;
+ }
+ }
+
+ public class ResultTreeObject extends TreeObject implements StatusAware {
+
+ public ResultTreeObject(String name) {
+ super(name);
+ }
+
+ private boolean isPassed = true;
+
+ public void setPassed(boolean isPassed) {
+ this.isPassed = isPassed;
+ }
+
+ public boolean isPassed() {
+ return isPassed;
+ }
+ }
+
+ // Specific inner classes
+ public class ResultPartNode extends ResultTreeObject {
+
+ private String status;
+ private String message;
+ private String exceptionMessage;
+
+ public ResultPartNode(String label, Integer status, String message) {
+ super(label);
+ handleStatus(status);
+ this.message = message;
+ }
+
+ public ResultPartNode(String label, Integer status, String message,
+ String exceptionMessage) {
+ super(label);
+ handleStatus(status);
+ this.message = message;
+ this.exceptionMessage = exceptionMessage;
+ }
+
+ private void handleStatus(Integer status) {
+ switch (status) {
+ case 0:
+ this.status = "PASSED";
+ setPassed(true);
+ break;
+ case 1:
+ this.status = "FAILED";
+ setPassed(false);
+ break;
+ case 2:
+ this.status = "ERROR";
+ setPassed(false);
+ break;
+ }
+ // for the moment being we don't have a relevant label
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public String getExceptionMessage() {
+ return exceptionMessage;
+ }
+ }
+}
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.client.contentprovider.ResultDetailContentProvider.ResultPartNode;
+import org.argeo.slc.client.contentprovider.ResultDetailContentProvider.StatusAware;
+import org.argeo.slc.client.ui.ClientUiPlugin;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * @author bsinou
+ *
+ * Fill ResultDetail view. Deported in an external bundle so that main
+ * slc ui bundle does not depend on DB implementation.
+ */
+public class ResultDetailLabelProvider extends LabelProvider implements
+ ITableLabelProvider {
+ // private static final Log log = LogFactory
+ // .getLog(ResultDetailLabelProvider.class);
+
+ public String getColumnText(Object obj, int index) {
+
+ if (obj instanceof TreeParent) {
+ if (index == 0)
+ return ((TreeParent) obj).getName();
+ else
+ return null;
+ }
+
+ if (obj instanceof ResultPartNode) {
+ ResultPartNode rpn = (ResultPartNode) obj;
+ switch (index) {
+ case 0:
+ return rpn.toString();
+ case 1:
+ return rpn.getStatus().toString();
+ case 2:
+ return rpn.getMessage();
+ case 3:
+ return rpn.getExceptionMessage();
+ }
+ return getText(obj);
+ }
+ return null;
+ }
+
+ public Image getImage(Object element) {
+ if (element instanceof StatusAware) {
+ if (((StatusAware) element).isPassed())
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("passedTest");
+ else
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("failedTest");
+ }
+ return null;
+ }
+
+ public Image getColumnImage(Object obj, int index) {
+ if (index == 0)
+ return getImage(obj);
+ else
+ return null;
+ }
+}
projects / gpl / argeo-slc.git / commitdiff