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