X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=eclipse%2Fplugins%2Forg.argeo.slc.client.ui%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fclient%2Fui%2Fviews%2FJcrExecutionModulesView.java;h=b33238e3cc4ea32b9f14f23931b3f8f6b30b5b54;hb=83996361545b06f97a85d20f3b5824af0a2c4904;hp=a06509c2102f7ad490bbf066cdddab26a3243de7;hpb=827cc6fa4bff1994f89cb8d925808def5600b5dc;p=gpl%2Fargeo-slc.git diff --git a/eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java b/eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java index a06509c21..b33238e3c 100644 --- a/eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java +++ b/eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java @@ -1,65 +1,114 @@ package org.argeo.slc.client.ui.views; -import java.io.ByteArrayOutputStream; -import java.io.IOException; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Iterator; import java.util.List; -import java.util.Properties; -import java.util.UUID; +import java.util.SortedSet; +import java.util.TreeSet; + +import javax.jcr.Node; +import javax.jcr.NodeIterator; +import javax.jcr.Property; +import javax.jcr.RepositoryException; +import javax.jcr.Session; +import javax.jcr.nodetype.NodeType; +import javax.jcr.observation.Event; +import javax.jcr.query.Query; +import javax.jcr.query.QueryManager; -import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.argeo.ArgeoException; +import org.argeo.eclipse.ui.jcr.AsyncUiEventListener; +import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider; +import org.argeo.eclipse.ui.jcr.NodeElementComparer; +import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider; +import org.argeo.slc.BasicNameVersion; +import org.argeo.slc.NameVersion; import org.argeo.slc.SlcException; -import org.argeo.slc.client.oxm.OxmInterface; -import org.argeo.slc.client.ui.ClientUiPlugin; -import org.argeo.slc.client.ui.controllers.ProcessController; -import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider; -import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider.FlowNode; -import org.argeo.slc.execution.ExecutionModuleDescriptor; -import org.argeo.slc.process.RealizedFlow; -import org.argeo.slc.process.SlcExecution; +import org.argeo.slc.client.ui.SlcImages; +import org.argeo.slc.client.ui.editors.ProcessEditor; +import org.argeo.slc.client.ui.editors.ProcessEditorInput; +import org.argeo.slc.execution.ExecutionModulesManager; +import org.argeo.slc.jcr.SlcJcrConstants; +import org.argeo.slc.jcr.SlcNames; +import org.argeo.slc.jcr.SlcTypes; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.jobs.Job; +import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; import org.eclipse.jface.viewers.DoubleClickEvent; -import org.eclipse.jface.viewers.IContentProvider; import org.eclipse.jface.viewers.IDoubleClickListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.ITableLabelProvider; -import org.eclipse.jface.viewers.LabelProvider; import org.eclipse.jface.viewers.TreeViewer; import org.eclipse.swt.SWT; import org.eclipse.swt.dnd.DND; +import org.eclipse.swt.dnd.DragSourceAdapter; import org.eclipse.swt.dnd.DragSourceEvent; -import org.eclipse.swt.dnd.DragSourceListener; import org.eclipse.swt.dnd.TextTransfer; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Composite; -import org.eclipse.ui.ISharedImages; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.part.ViewPart; -public class JcrExecutionModulesView extends ViewPart { +/** JCR based view of the execution modules. */ +public class JcrExecutionModulesView extends ViewPart implements SlcTypes, + SlcNames { private final static Log log = LogFactory .getLog(JcrExecutionModulesView.class); - public static final String ID = "org.argeo.slc.client.ui.executionModulesView"; + public static final String ID = "org.argeo.slc.client.ui.jcrExecutionModulesView"; private TreeViewer viewer; - // Ioc - private IContentProvider contentProvider; - private OxmInterface oxmBean; - private ProcessController processController; + private Session session; + + private ExecutionModulesManager modulesManager; public void createPartControl(Composite parent) { viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); + + // FIXME : does not work in RAP, find a way to have it for RCP only + // ColumnViewerToolTipSupport.enableFor(viewer); + + ViewContentProvider contentProvider = new ViewContentProvider(session); + viewer.setContentProvider(contentProvider); - viewer.setLabelProvider(new ViewLabelProvider()); + viewer.setComparer(new NodeElementComparer()); + final ViewLabelProvider viewLabelProvider = new ViewLabelProvider(); + viewer.setLabelProvider(viewLabelProvider); + // FIXME fail on RAP put it in specific + ColumnViewerToolTipSupport.enableFor(viewer); viewer.setInput(getViewSite()); viewer.addDoubleClickListener(new ViewDoubleClickListener()); - int operations = DND.DROP_COPY | DND.DROP_MOVE; + getViewSite().setSelectionProvider(viewer); + Transfer[] tt = new Transfer[] { TextTransfer.getInstance() }; + // Transfer[] tt = new Transfer[] { EditorInputTransfer.getInstance() }; + int operations = DND.DROP_COPY | DND.DROP_MOVE; viewer.addDragSupport(operations, tt, new ViewDragListener()); + + try { + String[] nodeTypes = { SlcTypes.SLC_AGENT, + SlcTypes.SLC_AGENT_FACTORY, SlcTypes.SLC_EXECUTION_MODULE }; + session.getWorkspace() + .getObservationManager() + .addEventListener( + new VmAgentObserver(viewer.getTree().getDisplay()), + Event.NODE_ADDED | Event.NODE_REMOVED + | Event.NODE_MOVED, + SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null, + nodeTypes, false); + } catch (RepositoryException e) { + throw new SlcException("Cannot add observer", e); + } } public void setFocus() { @@ -74,152 +123,334 @@ public class JcrExecutionModulesView extends ViewPart { viewer.setInput(getViewSite()); } - class ViewLabelProvider extends LabelProvider implements - ITableLabelProvider { - public String getColumnText(Object obj, int index) { - if (obj instanceof ExecutionModulesContentProvider.ExecutionModuleNode) { - ExecutionModuleDescriptor emd = ((ExecutionModulesContentProvider.ExecutionModuleNode) obj) - .getDescriptor(); - if (emd.getLabel() != null) { - return emd.getLabel(); - } else { - return getText(emd); - } - } else - return getText(obj); - } + class ViewContentProvider extends SimpleNodeContentProvider { - public Image getColumnImage(Object obj, int index) { - return getImage(obj); + public ViewContentProvider(Session session) { + super(session, + new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH }); } - public Image getImage(Object obj) { - if (obj instanceof ExecutionModulesContentProvider.AgentNode) - return ClientUiPlugin.getDefault().getImageRegistry() - .get("agent"); - else if (obj instanceof ExecutionModulesContentProvider.ExecutionModuleNode) - return ClientUiPlugin.getDefault().getImageRegistry() - .get("executionModule"); - else if (obj instanceof ExecutionModulesContentProvider.FolderNode) - return ClientUiPlugin.getDefault().getImageRegistry() - .get("folder"); - else if (obj instanceof ExecutionModulesContentProvider.FlowNode) - return ClientUiPlugin.getDefault().getImageRegistry() - .get("flow"); - else - return PlatformUI.getWorkbench().getSharedImages() - .getImage(ISharedImages.IMG_OBJ_ELEMENT); + // @Override + // protected Object[] getChildren(Node node) throws RepositoryException + // { + // if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY)) { + // List wrappers = new + // ArrayList(); + // for (NodeIterator nit = node.getNodes(); nit.hasNext();) { + // wrappers.add(new AgentNodesWrapper(nit.nextNode())); + // } + // return wrappers.toArray(); + // } + // return super.getChildren(node); + // } + + @Override + protected Object[] sort(Object parent, Object[] children) { + Object[] sorted = new Object[children.length]; + System.arraycopy(children, 0, sorted, 0, children.length); + Arrays.sort(sorted, new ViewComparator()); + return sorted; } - } - class ViewDoubleClickListener implements IDoubleClickListener { - public void doubleClick(DoubleClickEvent evt) { - Object obj = ((IStructuredSelection) evt.getSelection()) - .getFirstElement(); - if (obj instanceof ExecutionModulesContentProvider.FlowNode) { - ExecutionModulesContentProvider.FlowNode fn = (ExecutionModulesContentProvider.FlowNode) obj; - - List realizedFlows = new ArrayList(); - RealizedFlow realizedFlow = new RealizedFlow(); - realizedFlow.setModuleName(fn.getExecutionModuleNode() - .getDescriptor().getName()); - realizedFlow.setModuleVersion(fn.getExecutionModuleNode() - .getDescriptor().getVersion()); - realizedFlow.setFlowDescriptor(fn.getExecutionModuleNode() - .getFlowDescriptors().get(fn.getFlowName())); - realizedFlows.add(realizedFlow); - - SlcExecution slcExecution = new SlcExecution(); - slcExecution.setUuid(UUID.randomUUID().toString()); - slcExecution.setRealizedFlows(realizedFlows); - slcExecution.setHost(fn.getExecutionModuleNode().getAgentNode() - .getAgent().toString()); - processController.execute(fn.getExecutionModuleNode() - .getAgentNode().getAgent(), slcExecution); + @Override + protected List filterChildren(List children) + throws RepositoryException { + for (Iterator it = children.iterator(); it.hasNext();) { + Node node = it.next(); + // execution spec definitions + if (node.getName().equals(SLC_EXECUTION_SPECS)) + it.remove(); + // flow values + else if (node.getParent().isNodeType( + SlcTypes.SLC_EXECUTION_FLOW)) + it.remove(); } + return super.filterChildren(children); } + @Override + public boolean hasChildren(Object element) { + if (element instanceof Node) { + Node node = (Node) element; + try { + if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW)) + return false; + } catch (RepositoryException e) { + throw new SlcException("Cannot check has children", e); + } + } + return super.hasChildren(element); + } } - class ViewDragListener implements DragSourceListener { - - public void dragStart(DragSourceEvent event) { - System.out.println("Start Drag"); + static class ViewComparator implements Comparator { + + public int compare(Object o1, Object o2) { + try { + if (o1 instanceof Node && o2 instanceof Node) { + Node node1 = (Node) o1; + Node node2 = (Node) o2; + + if (node1.getName().equals(SLC_EXECUTION_SPECS)) + return -100; + if (node2.getName().equals(SLC_EXECUTION_SPECS)) + return 100; + + if (node1.isNodeType(SLC_EXECUTION_FLOW) + && node2.isNodeType(SLC_EXECUTION_FLOW)) { + return node1.getName().compareTo(node2.getName()); + } else if (node1.isNodeType(SLC_EXECUTION_FLOW) + && !node2.isNodeType(SLC_EXECUTION_FLOW)) { + return 1; + } else if (!node1.isNodeType(SLC_EXECUTION_FLOW) + && node2.isNodeType(SLC_EXECUTION_FLOW)) { + return -1; + } else { + // TODO: check title + return node1.getName().compareTo(node2.getName()); + } + } + } catch (RepositoryException e) { + throw new ArgeoException("Cannot compare " + o1 + " and " + o2, + e); + } + return 0; } - public void dragSetData(DragSourceEvent event) { - - // System.out.println("dragSetData: " + event); + } - IStructuredSelection selection = (IStructuredSelection) viewer - .getSelection(); - if (selection.getFirstElement() instanceof ExecutionModulesContentProvider.FlowNode) { + // /** Wraps the execution modules of an agent. */ + // static class AgentNodesWrapper extends NodesWrapper { + // + // public AgentNodesWrapper(Node node) { + // super(node); + // } + // + // protected List getWrappedNodes() + // throws RepositoryException { + // List children = new ArrayList(); + // Node executionModules = getNode(); + // for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) { + // for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions + // .hasNext();) { + // children.add(new WrappedNode(this, nitVersions.nextNode())); + // } + // } + // return children; + // } + // + // } + + class VmAgentObserver extends AsyncUiEventListener { + + public VmAgentObserver(Display display) { + super(display); + } - if (TextTransfer.getInstance().isSupportedType(event.dataType)) { - ExecutionModulesContentProvider.FlowNode flowNode = (ExecutionModulesContentProvider.FlowNode) selection - .getFirstElement(); - - Properties props = new Properties(); - flowNodeAsProperties(props, flowNode); - props.setProperty("agentId", flowNode - .getExecutionModuleNode().getAgentNode().getAgent() - .getAgentUuid()); - props.setProperty("host", flowNode.getExecutionModuleNode() - .getAgentNode().getAgent().toString()); - - ByteArrayOutputStream out = new ByteArrayOutputStream(); - try { - props.store(out, ""); - event.data = new String(out.toByteArray()); - } catch (IOException e) { - throw new SlcException( - "Cannot transform realized flow", e); - } finally { - IOUtils.closeQuietly(out); + protected void onEventInUiThread(List events) { + for (Event event : events) { + try { + String path = event.getPath(); + + if (session.itemExists(path)) { + Node parentNode = session.getNode(path);// .getParent(); + if (log.isTraceEnabled()) + log.trace("Refresh " + parentNode + " after event " + + event); + viewer.refresh(parentNode); } + } catch (RepositoryException e) { + log.warn("Cannot process event " + event + ": " + e); } } + + // try { + // Node vmAgentNode = session + // .getNode(SlcJcrConstants.VM_AGENT_FACTORY_PATH); + // viewer.refresh(vmAgentNode); + // } catch (RepositoryException e) { + // log.warn("Cannot process event : " + e); + // } + // TODO: optimize based on event + viewer.refresh(); } + } - public void dragFinished(DragSourceEvent event) { - System.out.println("Finished Drag"); + class ViewLabelProvider extends DefaultNodeLabelProvider implements + ITableLabelProvider { + + @Override + protected String getText(Node node) throws RepositoryException { + if (node.isNodeType(NodeType.MIX_TITLE) + && node.hasProperty(Property.JCR_TITLE)) + return node.getProperty(Property.JCR_TITLE).getString(); + else if (node.getName().equals(SLC_EXECUTION_SPECS)) + return "Execution Specifications"; + else if (node.getPath().equals( + SlcJcrConstants.VM_AGENT_FACTORY_PATH)) + return "Internal Agents"; + return super.getText(node); } - protected void flowNodeAsProperties(Properties props, FlowNode fn) { + @Override + public Image getImage(Node node) throws RepositoryException { + // we try to optimize a bit by putting deeper nodes first + if (node.getParent().isNodeType( + SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE)) + return SlcImages.CHOICES; + else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE)) + return SlcImages.EXECUTION_SPEC_ATTRIBUTE; + else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC)) + return SlcImages.EXECUTION_SPEC; + else if (node.getName().equals(SLC_EXECUTION_SPECS)) + return SlcImages.EXECUTION_SPECS; + else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW)) + return SlcImages.FLOW; + else if (node.isNodeType(SlcTypes.SLC_MODULE)) { + if (node.getProperty(SLC_STARTED).getBoolean()) + return SlcImages.MODULE; + else + return SlcImages.MODULE_STOPPED; + } else if (node.isNodeType(SlcTypes.SLC_AGENT)) + return SlcImages.AGENT; + else if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY)) + return SlcImages.AGENT_FACTORY; + else + return SlcImages.FOLDER; + } - RealizedFlow realizedFlow = new RealizedFlow(); - realizedFlow.setModuleName(fn.getExecutionModuleNode() - .getDescriptor().getName()); - realizedFlow.setModuleVersion(fn.getExecutionModuleNode() - .getDescriptor().getVersion()); - realizedFlow.setFlowDescriptor(fn.getExecutionFlowDescriptor()); + public String getToolTipText(Node node) throws RepositoryException { + if (node.isNodeType(NodeType.MIX_TITLE) + && node.hasProperty(Property.JCR_DESCRIPTION)) + return node.getProperty(Property.JCR_DESCRIPTION).getString(); + return super.getToolTipText(node); + } - // As we want to have the effective ExecutionSpec and not a - // reference; we store it at the RealizeFlow level : thus the - // marshaller will store the object and not only a reference. - realizedFlow.setExecutionSpec(fn.getExecutionFlowDescriptor() - .getExecutionSpec()); + public String getColumnText(Object obj, int index) { + return getText(obj); + } + + public Image getColumnImage(Object obj, int index) { + return getImage(obj); + } - props.setProperty("RealizedFlowAsXml", - oxmBean.marshal(realizedFlow)); - System.out - .println(oxmBean.marshal(fn.getExecutionFlowDescriptor())); + } + class ViewDoubleClickListener implements IDoubleClickListener { + public void doubleClick(DoubleClickEvent evt) { + Object obj = ((IStructuredSelection) evt.getSelection()) + .getFirstElement(); + try { + if (obj instanceof Node) { + Node node = (Node) obj; + if (node.isNodeType(SLC_EXECUTION_MODULE)) { + String name = node.getProperty(SLC_NAME).getString(); + String version = node.getProperty(SLC_VERSION) + .getString(); + final NameVersion nameVersion = new BasicNameVersion( + name, version); + Boolean started = node.getProperty(SLC_STARTED) + .getBoolean(); + + Job job; + if (started) { + job = new Job("Stop " + nameVersion) { + protected IStatus run(IProgressMonitor monitor) { + monitor.beginTask("Stop " + nameVersion, 1); + modulesManager.stop(nameVersion); + monitor.worked(1); + return Status.OK_STATUS; + } + }; + } else { + job = new Job("Start " + nameVersion) { + protected IStatus run(IProgressMonitor monitor) { + monitor.beginTask("Start " + nameVersion, 1); + modulesManager.start(nameVersion); + monitor.worked(1); + return Status.OK_STATUS; + } + }; + } + job.setUser(true); + job.schedule(); + } else { + String path = node.getPath(); + // TODO factorize with editor + QueryManager qm = node.getSession().getWorkspace() + .getQueryManager(); + String statement = "SELECT * FROM [" + + SlcTypes.SLC_EXECUTION_FLOW + + "] WHERE ISDESCENDANTNODE(['" + path + + "']) OR ISSAMENODE(['" + path + "'])"; + // log.debug(statement); + Query query = qm.createQuery(statement, Query.JCR_SQL2); + + // order paths + SortedSet paths = new TreeSet(); + for (NodeIterator nit = query.execute().getNodes(); nit + .hasNext();) { + paths.add(nit.nextNode().getPath()); + } + + // List paths = new ArrayList(); + // paths.add(node.getPath()); + IWorkbenchPage activePage = PlatformUI.getWorkbench() + .getActiveWorkbenchWindow().getActivePage(); + activePage.openEditor(new ProcessEditorInput( + new ArrayList(paths), true), + ProcessEditor.ID); + } + } + } catch (Exception e) { + throw new SlcException("Cannot open " + obj, e); + } } } - // IoC - public void setContentProvider(IContentProvider contentProvider) { - this.contentProvider = contentProvider; + class ViewDragListener extends DragSourceAdapter { + public void dragSetData(DragSourceEvent event) { + IStructuredSelection selection = (IStructuredSelection) viewer + .getSelection(); + if (selection.getFirstElement() instanceof Node) { + Node node = (Node) selection.getFirstElement(); + // try { + // if (node.isNodeType(SLC_EXECUTION_FLOW)) { + // if (EditorInputTransfer.getInstance().isSupportedType( + // event.dataType)) { + // ProcessEditorInput pei = new ProcessEditorInput( + // node.getPath()); + // EditorInputData eid = EditorInputTransfer + // .createEditorInputData(ProcessEditor.ID, + // pei); + // event.data = new EditorInputTransfer.EditorInputData[] { eid + // }; + // + // } + // } + // } catch (RepositoryException e1) { + // throw new SlcException("Cannot drag " + node, e1); + // } + + if (TextTransfer.getInstance().isSupportedType(event.dataType)) { + try { + event.data = node.getPath(); + } catch (RepositoryException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + } + } + } } - public void setProcessController(ProcessController processController) { - this.processController = processController; + public void setSession(Session session) { + this.session = session; } - public void setOxmBean(OxmInterface oxmBean) { - this.oxmBean = oxmBean; + public void setModulesManager(ExecutionModulesManager modulesManager) { + this.modulesManager = modulesManager; } } \ No newline at end of file