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
 153         static class ViewComparator implements Comparator<Object> {
 154
 155                 public int compare(Object o1, Object o2) {
 156                         try {
 157                                 if (o1 instanceof Node && o2 instanceof Node) {
 158                                         Node node1 = (Node) o1;
 159                                         Node node2 = (Node) o2;
 160
 161                                         if (node1.getName().equals(SLC_EXECUTION_SPECS))
 162                                                 return -100;
 163                                         if (node2.getName().equals(SLC_EXECUTION_SPECS))
 164                                                 return 100;
 165
 166                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 167                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 168                                                 return node1.getName().compareTo(node2.getName());
 169                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 170                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 171                                                 return 1;
 172                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 173                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 174                                                 return -1;
 175                                         } else {
 176                                                 // TODO: check title
 177                                                 return node1.getName().compareTo(node2.getName());
 178                                         }
 179                                 }
 180                         } catch (RepositoryException e) {
 181                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 182                                                 e);
 183                         }
 184                         return 0;
 185                 }
 186
 187         }
 188
 189         // /** Wraps the execution modules of an agent. */
 190         // static class AgentNodesWrapper extends NodesWrapper {
 191         //
 192         // public AgentNodesWrapper(Node node) {
 193         // super(node);
 194         // }
 195         //
 196         // protected List<WrappedNode> getWrappedNodes()
 197         // throws RepositoryException {
 198         // List<WrappedNode> children = new ArrayList<WrappedNode>();
 199         // Node executionModules = getNode();
 200         // for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 201         // for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 202         // .hasNext();) {
 203         // children.add(new WrappedNode(this, nitVersions.nextNode()));
 204         // }
 205         // }
 206         // return children;
 207         // }
 208         //
 209         // }
 210
 211         class VmAgentObserver extends AsyncUiEventListener {
 212                 protected void onEventInUiThread(EventIterator events) {
 213                         // List<Node> baseNodes = ((SimpleNodeContentProvider) viewer
 214                         // .getContentProvider()).getBaseNodes();
 215                         // Node baseNode = baseNodes.get(0);
 216                         //
 217                         // while (events.hasNext()) {
 218                         // Event event = events.nextEvent();
 219                         // try {
 220                         // String path = event.getPath();
 221                         // String baseNodePath = baseNode.getPath();
 222                         // if (path.startsWith(baseNodePath)) {
 223                         // String relPath = path
 224                         // .substring(baseNodePath.length() + 1);
 225                         // log.debug("relPath: " + relPath);
 226                         // if (baseNode.hasNode(relPath)) {
 227                         // Node refreshNode = baseNode.getNode(relPath);
 228                         // log.debug("refreshNode: " + refreshNode);
 229                         // viewer.refresh(refreshNode);
 230                         // }
 231                         //
 232                         // }
 233                         // // if (log.isDebugEnabled())
 234                         // // log.debug("Process " + path + ": " + event);
 235                         //
 236                         // // if (session.itemExists(path)) {
 237                         // // Node parentNode = session.getNode(path).getParent();
 238                         // // log.debug("Parent: " + parentNode);
 239                         // // viewer.refresh(parentNode);
 240                         // // }
 241                         // } catch (RepositoryException e) {
 242                         // log.warn("Cannot process event " + event + ": " + e);
 243                         // }
 244                         // }
 245
 246                         // try {
 247                         // Node vmAgentNode = session
 248                         // .getNode(SlcJcrConstants.VM_AGENT_FACTORY_PATH);
 249                         // viewer.refresh(vmAgentNode);
 250                         // } catch (RepositoryException e) {
 251                         // log.warn("Cannot process event : " + e);
 252                         // }
 253                         // TODO: optimize based on event
 254                         viewer.refresh();
 255                 }
 256         }
 257
 258         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 259                         ITableLabelProvider {
 260
 261                 @Override
 262                 protected String getText(Node node) throws RepositoryException {
 263                         if (node.getName().equals(SLC_EXECUTION_SPECS))
 264                                 return "Execution Specifications";
 265                         else if (node.getPath().equals(
 266                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH))
 267                                 return "Internal Agents";
 268                         return super.getText(node);
 269                 }
 270
 271                 @Override
 272                 public Image getImage(Node node) throws RepositoryException {
 273                         // we try to optimize a bit by putting deeper nodes first
 274                         if (node.getParent().isNodeType(
 275                                         SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 276                                 return SlcImages.CHOICES;
 277                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC_ATTRIBUTE))
 278                                 return SlcImages.EXECUTION_SPEC_ATTRIBUTE;
 279                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_SPEC))
 280                                 return SlcImages.EXECUTION_SPEC;
 281                         else if (node.getName().equals(SLC_EXECUTION_SPECS))
 282                                 return SlcImages.EXECUTION_SPECS;
 283                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 284                                 return SlcImages.FLOW;
 285                         else if (node.isNodeType(SlcTypes.SLC_MODULE)) {
 286                                 if (node.getProperty(SLC_STARTED).getBoolean())
 287                                         return SlcImages.MODULE;
 288                                 else
 289                                         return SlcImages.MODULE_STOPPED;
 290                         } else if (node.isNodeType(SlcTypes.SLC_AGENT))
 291                                 return SlcImages.AGENT;
 292                         else if (node.isNodeType(SlcTypes.SLC_AGENT_FACTORY))
 293                                 return SlcImages.AGENT_FACTORY;
 294                         else
 295                                 return SlcImages.FOLDER;
 296                 }
 297
 298                 public String getToolTipText(Node node) throws RepositoryException {
 299                         if (node.isNodeType(NodeType.MIX_TITLE)
 300                                         && node.hasProperty(Property.JCR_DESCRIPTION))
 301                                 return node.getProperty(Property.JCR_DESCRIPTION).getString();
 302                         return super.getToolTipText(node);
 303                 }
 304
 305                 public String getColumnText(Object obj, int index) {
 306                         return getText(obj);
 307                 }
 308
 309                 public Image getColumnImage(Object obj, int index) {
 310                         return getImage(obj);
 311                 }
 312
 313         }
 314
 315         class ViewDoubleClickListener implements IDoubleClickListener {
 316                 public void doubleClick(DoubleClickEvent evt) {
 317                         Object obj = ((IStructuredSelection) evt.getSelection())
 318                                         .getFirstElement();
 319                         try {
 320                                 if (obj instanceof Node) {
 321                                         Node node = (Node) obj;
 322                                         if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 323                                                 List<String> paths = new ArrayList<String>();
 324                                                 paths.add(node.getPath());
 325                                                 IWorkbenchPage activePage = PlatformUI.getWorkbench()
 326                                                                 .getActiveWorkbenchWindow().getActivePage();
 327                                                 activePage.openEditor(new ProcessEditorInput(paths,
 328                                                                 true), ProcessEditor.ID);
 329                                         } else if (node.isNodeType(SLC_EXECUTION_MODULE)) {
 330                                                 String name = node.getProperty(SLC_NAME).getString();
 331                                                 String version = node.getProperty(SLC_VERSION)
 332                                                                 .getString();
 333                                                 NameVersion nameVersion = new BasicNameVersion(name,
 334                                                                 version);
 335                                                 Boolean started = node.getProperty(SLC_STARTED)
 336                                                                 .getBoolean();
 337                                                 if (started) {
 338                                                         modulesManager.stop(nameVersion);
 339                                                 } else {
 340                                                         modulesManager.start(nameVersion);
 341                                                 }
 342                                         }
 343                                 }
 344                         } catch (Exception e) {
 345                                 throw new SlcException("Cannot open " + obj, e);
 346                         }
 347                 }
 348
 349         }
 350
 351         class ViewDragListener extends DragSourceAdapter {
 352                 public void dragSetData(DragSourceEvent event) {
 353                         IStructuredSelection selection = (IStructuredSelection) viewer
 354                                         .getSelection();
 355                         if (selection.getFirstElement() instanceof Node) {
 356                                 Node node = (Node) selection.getFirstElement();
 357                                 // try {
 358                                 // if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 359                                 // if (EditorInputTransfer.getInstance().isSupportedType(
 360                                 // event.dataType)) {
 361                                 // ProcessEditorInput pei = new ProcessEditorInput(
 362                                 // node.getPath());
 363                                 // EditorInputData eid = EditorInputTransfer
 364                                 // .createEditorInputData(ProcessEditor.ID,
 365                                 // pei);
 366                                 // event.data = new EditorInputTransfer.EditorInputData[] { eid
 367                                 // };
 368                                 //
 369                                 // }
 370                                 // }
 371                                 // } catch (RepositoryException e1) {
 372                                 // throw new SlcException("Cannot drag " + node, e1);
 373                                 // }
 374
 375                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 376                                         try {
 377                                                 event.data = node.getPath();
 378                                         } catch (RepositoryException e1) {
 379                                                 // TODO Auto-generated catch block
 380                                                 e1.printStackTrace();
 381                                         }
 382                                 }
 383                         }
 384                 }
 385         }
 386
 387         public void setSession(Session session) {
 388                 this.session = session;
 389         }
 390
 391         public void setModulesManager(ExecutionModulesManager modulesManager) {
 392                 this.modulesManager = modulesManager;
 393         }
 394
 395 }