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.List;
   7 import java.util.Properties;
   8
   9 import javax.jcr.Node;
  10 import javax.jcr.NodeIterator;
  11 import javax.jcr.Property;
  12 import javax.jcr.RepositoryException;
  13 import javax.jcr.Session;
  14 import javax.jcr.observation.Event;
  15 import javax.jcr.observation.EventIterator;
  16 import javax.jcr.observation.EventListener;
  17
  18 import org.apache.commons.logging.Log;
  19 import org.apache.commons.logging.LogFactory;
  20 import org.argeo.ArgeoException;
  21 import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  22 import org.argeo.eclipse.ui.jcr.NodesWrapper;
  23 import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  24 import org.argeo.eclipse.ui.jcr.WrappedNode;
  25 import org.argeo.slc.SlcException;
  26 import org.argeo.slc.client.ui.SlcImages;
  27 import org.argeo.slc.client.ui.controllers.ProcessController;
  28 import org.argeo.slc.client.ui.editors.ProcessEditor;
  29 import org.argeo.slc.client.ui.editors.ProcessEditorInput;
  30 import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider.FlowNode;
  31 import org.argeo.slc.jcr.SlcJcrConstants;
  32 import org.argeo.slc.jcr.SlcNames;
  33 import org.argeo.slc.jcr.SlcTypes;
  34 import org.argeo.slc.process.RealizedFlow;
  35 import org.eclipse.jface.viewers.ColumnViewerToolTipSupport;
  36 import org.eclipse.jface.viewers.DoubleClickEvent;
  37 import org.eclipse.jface.viewers.IDoubleClickListener;
  38 import org.eclipse.jface.viewers.IStructuredSelection;
  39 import org.eclipse.jface.viewers.ITableLabelProvider;
  40 import org.eclipse.jface.viewers.TreeViewer;
  41 import org.eclipse.swt.SWT;
  42 import org.eclipse.swt.dnd.DND;
  43 import org.eclipse.swt.dnd.DragSourceAdapter;
  44 import org.eclipse.swt.dnd.DragSourceEvent;
  45 import org.eclipse.swt.dnd.TextTransfer;
  46 import org.eclipse.swt.dnd.Transfer;
  47 import org.eclipse.swt.graphics.Image;
  48 import org.eclipse.swt.widgets.Composite;
  49 import org.eclipse.ui.PlatformUI;
  50 import org.eclipse.ui.part.ViewPart;
  51
  52 public class JcrExecutionModulesView extends ViewPart implements SlcTypes,
  53                 SlcNames {
  54         private final static Log log = LogFactory
  55                         .getLog(JcrExecutionModulesView.class);
  56
  57         public static final String ID = "org.argeo.slc.client.ui.jcrExecutionModulesView";
  58
  59         private TreeViewer viewer;
  60
  61         private Session session;
  62
  63         private ProcessController processController;
  64
  65         public void createPartControl(Composite parent) {
  66                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  67                 ColumnViewerToolTipSupport.enableFor(viewer);
  68
  69                 ViewContentProvider contentProvider = new ViewContentProvider(session);
  70
  71                 viewer.setContentProvider(contentProvider);
  72                 final ViewLabelProvider viewLabelProvider = new ViewLabelProvider();
  73                 viewer.setLabelProvider(viewLabelProvider);
  74                 viewer.setInput(getViewSite());
  75                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  76
  77                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  78                 // Transfer[] tt = new Transfer[] { EditorInputTransfer.getInstance() };
  79                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  80                 viewer.addDragSupport(operations, tt, new ViewDragListener());
  81
  82                 try {
  83                         session.getWorkspace()
  84                                         .getObservationManager()
  85                                         .addEventListener(
  86                                                         new VmAgentObserver(),
  87                                                         Event.NODE_ADDED | Event.NODE_REMOVED
  88                                                                         | Event.NODE_MOVED,
  89                                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null,
  90                                                         null, false);
  91                 } catch (RepositoryException e) {
  92                         throw new SlcException("Cannot add observer", e);
  93                 }
  94         }
  95
  96         public void setFocus() {
  97                 viewer.getControl().setFocus();
  98         }
  99
 100         public TreeViewer getViewer() {
 101                 return viewer;
 102         }
 103
 104         public void refreshView() {
 105                 viewer.setInput(getViewSite());
 106         }
 107
 108         class ViewContentProvider extends SimpleNodeContentProvider {
 109
 110                 public ViewContentProvider(Session session) {
 111                         super(session,
 112                                         new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
 113                 }
 114
 115                 @Override
 116                 protected Object[] getChildren(Node node) throws RepositoryException {
 117                         if (node.isNodeType(SlcTypes.SLC_AGENT_PROXY)) {
 118                                 List<AgentNodesWrapper> wrappers = new ArrayList<AgentNodesWrapper>();
 119                                 for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
 120                                         wrappers.add(new AgentNodesWrapper(nit.nextNode()));
 121                                 }
 122                                 return wrappers.toArray();
 123                         }
 124                         return super.getChildren(node);
 125                 }
 126
 127                 @Override
 128                 protected Object[] sort(Object parent, Object[] children) {
 129                         Object[] sorted = new Object[children.length];
 130                         System.arraycopy(children, 0, sorted, 0, children.length);
 131                         Arrays.sort(sorted, new ViewComparator());
 132                         return sorted;
 133                 }
 134         }
 135
 136         static class ViewComparator implements Comparator<Object> {
 137
 138                 public int compare(Object o1, Object o2) {
 139                         try {
 140                                 if (o1 instanceof Node && o2 instanceof Node) {
 141                                         Node node1 = (Node) o1;
 142                                         Node node2 = (Node) o2;
 143                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 144                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 145                                                 return node1.getName().compareTo(node2.getName());
 146                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 147                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 148                                                 return 1;
 149                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 150                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 151                                                 return -1;
 152                                         } else {
 153                                                 // TODO: check title
 154                                                 return node1.getName().compareTo(node2.getName());
 155                                         }
 156                                 }
 157                         } catch (RepositoryException e) {
 158                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 159                                                 e);
 160                         }
 161                         return 0;
 162                 }
 163
 164         }
 165
 166         /** Wraps the execution modules of an agent. */
 167         static class AgentNodesWrapper extends NodesWrapper {
 168
 169                 public AgentNodesWrapper(Node node) {
 170                         super(node);
 171                 }
 172
 173                 protected List<WrappedNode> getWrappedNodes()
 174                                 throws RepositoryException {
 175                         List<WrappedNode> children = new ArrayList<WrappedNode>();
 176                         Node executionModules = getNode().getNode(
 177                                         SlcNames.SLC_EXECUTION_MODULES);
 178                         for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 179                                 for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 180                                                 .hasNext();) {
 181                                         children.add(new WrappedNode(this, nitVersions.nextNode()));
 182                                 }
 183                         }
 184                         return children;
 185                 }
 186
 187         }
 188
 189         class VmAgentObserver implements EventListener {
 190
 191                 public void onEvent(EventIterator events) {
 192                         viewer.refresh();
 193                 }
 194
 195         }
 196
 197         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 198                         ITableLabelProvider {
 199                 public String getColumnText(Object obj, int index) {
 200                         return getText(obj);
 201                 }
 202
 203                 public Image getColumnImage(Object obj, int index) {
 204                         return getImage(obj);
 205                 }
 206
 207                 public Image getImage(Node node) throws RepositoryException {
 208                         if (node.getParent().isNodeType(SlcTypes.SLC_AGENT_PROXY))
 209                                 return SlcImages.AGENT;
 210                         else if (node.isNodeType(SlcTypes.SLC_MODULE))
 211                                 return SlcImages.MODULE;
 212                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 213                                 return SlcImages.FLOW;
 214                         else
 215                                 return SlcImages.FOLDER;
 216                 }
 217
 218                 public String getToolTipText(Node node) throws RepositoryException {
 219                         if (node.isNodeType(SlcTypes.SLC_MODULE)
 220                                         && node.hasProperty(Property.JCR_DESCRIPTION))
 221                                 return node.getProperty(Property.JCR_DESCRIPTION).getString();
 222                         return super.getToolTipText(node);
 223                 }
 224
 225         }
 226
 227         class ViewDoubleClickListener implements IDoubleClickListener {
 228                 public void doubleClick(DoubleClickEvent evt) {
 229                         Object obj = ((IStructuredSelection) evt.getSelection())
 230                                         .getFirstElement();
 231                         try {
 232                                 if (obj instanceof Node) {
 233                                         Node node = (Node) obj;
 234                                         if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 235                                                 List<String> paths = new ArrayList<String>();
 236                                                 paths.add(node.getPath());
 237                                                 PlatformUI
 238                                                                 .getWorkbench()
 239                                                                 .getActiveWorkbenchWindow()
 240                                                                 .getActivePage()
 241                                                                 .openEditor(
 242                                                                                 new ProcessEditorInput(paths, true),
 243                                                                                 ProcessEditor.ID);
 244                                         }
 245                                 }
 246                         } catch (Exception e) {
 247                                 throw new SlcException("Cannot open " + obj, e);
 248                         }
 249
 250                         // if (obj instanceof ExecutionModulesContentProvider.FlowNode) {
 251                         // ExecutionModulesContentProvider.FlowNode fn =
 252                         // (ExecutionModulesContentProvider.FlowNode) obj;
 253                         //
 254                         // List<RealizedFlow> realizedFlows = new ArrayList<RealizedFlow>();
 255                         // RealizedFlow realizedFlow = new RealizedFlow();
 256                         // realizedFlow.setModuleName(fn.getExecutionModuleNode()
 257                         // .getDescriptor().getName());
 258                         // realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 259                         // .getDescriptor().getVersion());
 260                         // realizedFlow.setFlowDescriptor(fn.getExecutionModuleNode()
 261                         // .getFlowDescriptors().get(fn.getFlowName()));
 262                         // realizedFlows.add(realizedFlow);
 263                         //
 264                         // SlcExecution slcExecution = new SlcExecution();
 265                         // slcExecution.setUuid(UUID.randomUUID().toString());
 266                         // slcExecution.setRealizedFlows(realizedFlows);
 267                         // slcExecution.setHost(fn.getExecutionModuleNode().getAgentNode()
 268                         // .getAgent().toString());
 269                         // processController.execute(fn.getExecutionModuleNode()
 270                         // .getAgentNode().getAgent(), slcExecution);
 271                         // }
 272                 }
 273
 274         }
 275
 276         class ViewDragListener extends DragSourceAdapter {
 277
 278                 public void dragStart(DragSourceEvent event) {
 279                         if (log.isDebugEnabled())
 280                                 log.debug("Start Drag " + event);
 281                         super.dragStart(event);
 282                 }
 283
 284                 public void dragSetData(DragSourceEvent event) {
 285
 286                         // System.out.println("dragSetData: " + event);
 287
 288                         IStructuredSelection selection = (IStructuredSelection) viewer
 289                                         .getSelection();
 290                         if (selection.getFirstElement() instanceof Node) {
 291                                 Node node = (Node) selection.getFirstElement();
 292                                 // try {
 293                                 // if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 294                                 // if (EditorInputTransfer.getInstance().isSupportedType(
 295                                 // event.dataType)) {
 296                                 // ProcessEditorInput pei = new ProcessEditorInput(
 297                                 // node.getPath());
 298                                 // EditorInputData eid = EditorInputTransfer
 299                                 // .createEditorInputData(ProcessEditor.ID,
 300                                 // pei);
 301                                 // event.data = new EditorInputTransfer.EditorInputData[] { eid
 302                                 // };
 303                                 //
 304                                 // }
 305                                 // }
 306                                 // } catch (RepositoryException e1) {
 307                                 // throw new SlcException("Cannot drag " + node, e1);
 308                                 // }
 309
 310                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 311                                         try {
 312                                                 event.data = node.getPath();
 313                                         } catch (RepositoryException e1) {
 314                                                 // TODO Auto-generated catch block
 315                                                 e1.printStackTrace();
 316                                         }
 317                                         //
 318                                         // // ExecutionModulesContentProvider.FlowNode flowNode =
 319                                         // (ExecutionModulesContentProvider.FlowNode) selection
 320                                         // // .getFirstElement();
 321                                         // //
 322                                         // // Properties props = new Properties();
 323                                         // // flowNodeAsProperties(props, flowNode);
 324                                         // // props.setProperty("agentId", flowNode
 325                                         // // .getExecutionModuleNode().getAgentNode().getAgent()
 326                                         // // .getAgentUuid());
 327                                         // // props.setProperty("host",
 328                                         // flowNode.getExecutionModuleNode()
 329                                         // // .getAgentNode().getAgent().toString());
 330                                         // //
 331                                         // // ByteArrayOutputStream out = new
 332                                         // ByteArrayOutputStream();
 333                                         // // try {
 334                                         // // props.store(out, "");
 335                                         // // event.data = new String(out.toByteArray());
 336                                         // // } catch (IOException e) {
 337                                         // // throw new SlcException(
 338                                         // // "Cannot transform realized flow", e);
 339                                         // // } finally {
 340                                         // // IOUtils.closeQuietly(out);
 341                                         // // }
 342                                 }
 343                         }
 344                 }
 345
 346                 public void dragFinished(DragSourceEvent event) {
 347                         if (log.isDebugEnabled())
 348                                 log.debug("Finished Drag " + event);
 349                 }
 350
 351                 protected void flowNodeAsProperties(Properties props, FlowNode fn) {
 352
 353                         RealizedFlow realizedFlow = new RealizedFlow();
 354                         realizedFlow.setModuleName(fn.getExecutionModuleNode()
 355                                         .getDescriptor().getName());
 356                         realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 357                                         .getDescriptor().getVersion());
 358                         realizedFlow.setFlowDescriptor(fn.getExecutionFlowDescriptor());
 359
 360                         // As we want to have the effective ExecutionSpec and not a
 361                         // reference; we store it at the RealizeFlow level : thus the
 362                         // marshaller will store the object and not only a reference.
 363                         realizedFlow.setExecutionSpec(fn.getExecutionFlowDescriptor()
 364                                         .getExecutionSpec());
 365
 366                         // props.setProperty("RealizedFlowAsXml",
 367                         // oxmBean.marshal(realizedFlow));
 368                         // System.out
 369                         // .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
 370
 371                 }
 372
 373         }
 374
 375         public void setProcessController(ProcessController processController) {
 376                 this.processController = processController;
 377         }
 378
 379         public void setSession(Session session) {
 380                 this.session = session;
 381         }
 382
 383 }