eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java

   1 package org.argeo.slc.client.ui.views;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Comparator;
   6 import java.util.Iterator;
   7 import java.util.List;
   8
   9 import javax.jcr.Node;
  10 import javax.jcr.Property;
  11 import javax.jcr.RepositoryException;
  12 import javax.jcr.Session;
  13 import javax.jcr.nodetype.NodeType;
  14 import javax.jcr.observation.Event;
  15 import javax.jcr.observation.EventIterator;
  16
  17 import org.argeo.ArgeoException;
  18 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  19 import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  20 import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  21 import org.argeo.slc.BasicNameVersion;
  22 import org.argeo.slc.NameVersion;
  23 import org.argeo.slc.SlcException;
  24 import org.argeo.slc.client.ui.SlcImages;
  25 import org.argeo.slc.client.ui.editors.ProcessEditor;
  26 import org.argeo.slc.client.ui.editors.ProcessEditorInput;
  27 import org.argeo.slc.execution.ExecutionModulesManager;
  28 import org.argeo.slc.jcr.SlcJcrConstants;
  29 import org.argeo.slc.jcr.SlcNames;
  30 import org.argeo.slc.jcr.SlcTypes;
  31 import org.eclipse.jface.viewers.ColumnViewerToolTipSupport;
  32 import org.eclipse.jface.viewers.DoubleClickEvent;
  33 import org.eclipse.jface.viewers.IDoubleClickListener;
  34 import org.eclipse.jface.viewers.IStructuredSelection;
  35 import org.eclipse.jface.viewers.ITableLabelProvider;
  36 import org.eclipse.jface.viewers.TreeViewer;
  37 import org.eclipse.swt.SWT;
  38 import org.eclipse.swt.dnd.DND;
  39 import org.eclipse.swt.dnd.DragSourceAdapter;
  40 import org.eclipse.swt.dnd.DragSourceEvent;
  41 import org.eclipse.swt.dnd.TextTransfer;
  42 import org.eclipse.swt.dnd.Transfer;
  43 import org.eclipse.swt.graphics.Image;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.ui.IWorkbenchPage;
  46 import org.eclipse.ui.PlatformUI;
  47 import org.eclipse.ui.part.ViewPart;
  48
  49 /** JCR based view of the execution modules. */
  50 public class JcrExecutionModulesView extends ViewPart implements SlcTypes,
  51                 SlcNames {
  52         // private final static Log log = LogFactory
  53         // .getLog(JcrExecutionModulesView.class);
  54
  55         public static final String ID = "org.argeo.slc.client.ui.jcrExecutionModulesView";
  56
  57         private TreeViewer viewer;
  58
  59         private Session session;
  60
  61         private ExecutionModulesManager modulesManager;
  62
  63         public void createPartControl(Composite parent) {
  64                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  65                 ColumnViewerToolTipSupport.enableFor(viewer);
  66
  67                 ViewContentProvider contentProvider = new ViewContentProvider(session);
  68
  69                 viewer.setContentProvider(contentProvider);
  70                 final ViewLabelProvider viewLabelProvider = new ViewLabelProvider();
  71                 viewer.setLabelProvider(viewLabelProvider);
  72                 viewer.setInput(getViewSite());
  73                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  74                 getViewSite().setSelectionProvider(viewer);
  75
  76                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  77                 // Transfer[] tt = new Transfer[] { EditorInputTransfer.getInstance() };
  78                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  79                 viewer.addDragSupport(operations, tt, new ViewDragListener());
  80
  81                 try {
  82                         session.getWorkspace()
  83                                         .getObservationManager()
  84                                         .addEventListener(
  85                                                         new VmAgentObserver(),
  86                                                         Event.NODE_ADDED | Event.NODE_REMOVED
  87                                                                         | Event.NODE_MOVED,
  88                                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null,
  89                                                         null, false);
  90                 } catch (RepositoryException e) {
  91                         throw new SlcException("Cannot add observer", e);
  92                 }
  93         }
  94
  95         public void setFocus() {
  96                 viewer.getControl().setFocus();
  97         }
  98
  99         public TreeViewer getViewer() {
 100                 return viewer;
 101         }
 102
 103         public void refreshView() {
 104                 viewer.setInput(getViewSite());
 105         }
 106
 107         class ViewContentProvider extends SimpleNodeContentProvider {
 108
 109                 public ViewContentProvider(Session session) {
 110                         super(session,
 111                                         new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
 112                 }
 113
 114                 // @Override
 115                 // protected Object[] getChildren(Node node) throws RepositoryException
 116                 // {
 117                 // if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY)) {
 118                 // List<AgentNodesWrapper> wrappers = new
 119                 // ArrayList<AgentNodesWrapper>();
 120                 // for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
 121                 // wrappers.add(new AgentNodesWrapper(nit.nextNode()));
 122                 // }
 123                 // return wrappers.toArray();
 124                 // }
 125                 // return super.getChildren(node);
 126                 // }
 127
 128                 @Override
 129                 protected Object[] sort(Object parent, Object[] children) {
 130                         Object[] sorted = new Object[children.length];
 131                         System.arraycopy(children, 0, sorted, 0, children.length);
 132                         Arrays.sort(sorted, new ViewComparator());
 133                         return sorted;
 134                 }
 135
 136                 @Override
 137                 protected List<Node> filterChildren(List<Node> children)
 138                                 throws RepositoryException {
 139                         for (Iterator<Node> it = children.iterator(); it.hasNext();) {
 140                                 Node node = it.next();
 141                                 // execution spec definitions
 142                                 if (node.getName().equals(SLC_EXECUTION_SPECS))
 143                                         it.remove();
 144                                 // flow values
 145                                 else if (node.getParent().isNodeType(
 146                                                 SlcTypes.SLC_EXECUTION_FLOW))
 147                                         it.remove();
 148                         }
 149                         return super.filterChildren(children);
 150                 }
 151
 152                 @Override
 153                 public boolean hasChildren(Object element) {
 154                         if (element instanceof Node) {
 155                                 Node node = (Node) element;
 156                                 try {
 157                                         if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 158                                                 return false;
 159                                 } catch (RepositoryException e) {
 160                                         throw new SlcException("Cannot check has children", e);
 161                                 }
 162                         }
 163                         return super.hasChildren(element);
 164                 }
 165         }
 166
 167         static class ViewComparator implements Comparator<Object> {
 168
 169                 public int compare(Object o1, Object o2) {
 170                         try {
 171                                 if (o1 instanceof Node && o2 instanceof Node) {
 172                                         Node node1 = (Node) o1;
 173                                         Node node2 = (Node) o2;
 174
 175                                         if (node1.getName().equals(SLC_EXECUTION_SPECS))
 176                                                 return -100;
 177                                         if (node2.getName().equals(SLC_EXECUTION_SPECS))
 178                                                 return 100;
 179
 180                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 181                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 182                                                 return node1.getName().compareTo(node2.getName());
 183                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 184                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 185                                                 return 1;
 186                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 187                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 188                                                 return -1;
 189                                         } else {
 190                                                 // TODO: check title
 191                                                 return node1.getName().compareTo(node2.getName());
 192                                         }
 193                                 }
 194                         } catch (RepositoryException e) {
 195                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 196                                                 e);
 197                         }
 198                         return 0;
 199                 }
 200
 201         }
 202
 203         // /** Wraps the execution modules of an agent. */
 204         // static class AgentNodesWrapper extends NodesWrapper {
 205         //
 206         // public AgentNodesWrapper(Node node) {
 207         // super(node);
 208         // }
 209         //
 210         // protected List<WrappedNode> getWrappedNodes()
 211         // throws RepositoryException {
 212         // List<WrappedNode> children = new ArrayList<WrappedNode>();
 213         // Node executionModules = getNode();
 214         // for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 215         // for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 216         // .hasNext();) {
 217         // children.add(new WrappedNode(this, nitVersions.nextNode()));
 218         // }
 219         // }
 220         // return children;
 221         // }
 222         //
 223         // }
 224
 225         class VmAgentObserver extends AsyncUiEventListener {
 226                 protected void onEventInUiThread(EventIterator events) {
 227                         // List<Node> baseNodes = ((SimpleNodeContentProvider) viewer
 228                         // .getContentProvider()).getBaseNodes();
 229                         // Node baseNode = baseNodes.get(0);
 230                         //
 231                         // while (events.hasNext()) {
 232                         // Event event = events.nextEvent();
 233                         // try {
 234                         // String path = event.getPath();
 235                         // String baseNodePath = baseNode.getPath();
 236                         // if (path.startsWith(baseNodePath)) {
 237                         // String relPath = path
 238                         // .substring(baseNodePath.length() + 1);
 239                         // log.debug("relPath: " + relPath);
 240                         // if (baseNode.hasNode(relPath)) {
 241                         // Node refreshNode = baseNode.getNode(relPath);
 242                         // log.debug("refreshNode: " + refreshNode);
 243                         // viewer.refresh(refreshNode);
 244                         // }
 245                         //
 246                         // }
 247                         // // if (log.isDebugEnabled())
 248                         // // log.debug("Process " + path + ": " + event);
 249                         //
 250                         // // if (session.itemExists(path)) {
 251                         // // Node parentNode = session.getNode(path).getParent();
 252                         // // log.debug("Parent: " + parentNode);
 253                         // // viewer.refresh(parentNode);
 254                         // // }
 255                         // } catch (RepositoryException e) {
 256                         // log.warn("Cannot process event " + event + ": " + e);
 257                         // }
 258                         // }
 259
 260                         // try {
 261                         // Node vmAgentNode = session
 262                         // .getNode(SlcJcrConstants.VM_AGENT_FACTORY_PATH);
 263                         // viewer.refresh(vmAgentNode);
 264                         // } catch (RepositoryException e) {
 265                         // log.warn("Cannot process event : " + e);
 266                         // }
 267                         // TODO: optimize based on event
 268                         viewer.refresh();
 269                 }
 270         }
 271
 272         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 273                         ITableLabelProvider {
 274
 275                 @Override
 276                 protected String getText(Node node) throws RepositoryException {
 277                         if (node.getName().equals(SLC_EXECUTION_SPECS))
 278                                 return "Execution Specifications";
 279                         else if (node.getPath().equals(
 280                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH))
 281                                 return "Internal Agents";
 282                         return super.getText(node);
 283                 }
 284
 285                 @Override
 286                 public Image getImage(Node node) throws RepositoryException {
 287                         // we try to optimize a bit by putting deeper nodes first
 288                         if (node.getParent().isNodeType(
 289                                         SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 290                                 return SlcImages.CHOICES;
 291                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 292                                 return SlcImages.EXECUTION_SPEC_ATTRIBUTE;
 293                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC))
 294                                 return SlcImages.EXECUTION_SPEC;
 295                         else if (node.getName().equals(SLC_EXECUTION_SPECS))
 296                                 return SlcImages.EXECUTION_SPECS;
 297                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 298                                 return SlcImages.FLOW;
 299                         else if (node.isNodeType(SlcTypes.SLC_MODULE)) {
 300                                 if (node.getProperty(SLC_STARTED).getBoolean())
 301                                         return SlcImages.MODULE;
 302                                 else
 303                                         return SlcImages.MODULE_STOPPED;
 304                         } else if (node.isNodeType(SlcTypes.SLC_AGENT))
 305                                 return SlcImages.AGENT;
 306                         else if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY))
 307                                 return SlcImages.AGENT_FACTORY;
 308                         else
 309                                 return SlcImages.FOLDER;
 310                 }
 311
 312                 public String getToolTipText(Node node) throws RepositoryException {
 313                         if (node.isNodeType(NodeType.MIX_TITLE)
 314                                         && node.hasProperty(Property.JCR_DESCRIPTION))
 315                                 return node.getProperty(Property.JCR_DESCRIPTION).getString();
 316                         return super.getToolTipText(node);
 317                 }
 318
 319                 public String getColumnText(Object obj, int index) {
 320                         return getText(obj);
 321                 }
 322
 323                 public Image getColumnImage(Object obj, int index) {
 324                         return getImage(obj);
 325                 }
 326
 327         }
 328
 329         class ViewDoubleClickListener implements IDoubleClickListener {
 330                 public void doubleClick(DoubleClickEvent evt) {
 331                         Object obj = ((IStructuredSelection) evt.getSelection())
 332                                         .getFirstElement();
 333                         try {
 334                                 if (obj instanceof Node) {
 335                                         Node node = (Node) obj;
 336                                         if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 337                                                 List<String> paths = new ArrayList<String>();
 338                                                 paths.add(node.getPath());
 339                                                 IWorkbenchPage activePage = PlatformUI.getWorkbench()
 340                                                                 .getActiveWorkbenchWindow().getActivePage();
 341                                                 activePage.openEditor(new ProcessEditorInput(paths,
 342                                                                 true), ProcessEditor.ID);
 343                                         } else if (node.isNodeType(SLC_EXECUTION_MODULE)) {
 344                                                 String name = node.getProperty(SLC_NAME).getString();
 345                                                 String version = node.getProperty(SLC_VERSION)
 346                                                                 .getString();
 347                                                 NameVersion nameVersion = new BasicNameVersion(name,
 348                                                                 version);
 349                                                 Boolean started = node.getProperty(SLC_STARTED)
 350                                                                 .getBoolean();
 351                                                 if (started) {
 352                                                         modulesManager.stop(nameVersion);
 353                                                 } else {
 354                                                         modulesManager.start(nameVersion);
 355                                                 }
 356                                         }
 357                                 }
 358                         } catch (Exception e) {
 359                                 throw new SlcException("Cannot open " + obj, e);
 360                         }
 361                 }
 362
 363         }
 364
 365         class ViewDragListener extends DragSourceAdapter {
 366                 public void dragSetData(DragSourceEvent event) {
 367                         IStructuredSelection selection = (IStructuredSelection) viewer
 368                                         .getSelection();
 369                         if (selection.getFirstElement() instanceof Node) {
 370                                 Node node = (Node) selection.getFirstElement();
 371                                 // try {
 372                                 // if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 373                                 // if (EditorInputTransfer.getInstance().isSupportedType(
 374                                 // event.dataType)) {
 375                                 // ProcessEditorInput pei = new ProcessEditorInput(
 376                                 // node.getPath());
 377                                 // EditorInputData eid = EditorInputTransfer
 378                                 // .createEditorInputData(ProcessEditor.ID,
 379                                 // pei);
 380                                 // event.data = new EditorInputTransfer.EditorInputData[] { eid
 381                                 // };
 382                                 //
 383                                 // }
 384                                 // }
 385                                 // } catch (RepositoryException e1) {
 386                                 // throw new SlcException("Cannot drag " + node, e1);
 387                                 // }
 388
 389                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 390                                         try {
 391                                                 event.data = node.getPath();
 392                                         } catch (RepositoryException e1) {
 393                                                 // TODO Auto-generated catch block
 394                                                 e1.printStackTrace();
 395                                         }
 396                                 }
 397                         }
 398                 }
 399         }
 400
 401         public void setSession(Session session) {
 402                 this.session = session;
 403         }
 404
 405         public void setModulesManager(ExecutionModulesManager modulesManager) {
 406                 this.modulesManager = modulesManager;
 407         }
 408
 409 }