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.io.ByteArrayOutputStream;
   4 import java.io.IOException;
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.Comparator;
   8 import java.util.List;
   9 import java.util.Properties;
  10 import java.util.UUID;
  11
  12 import javax.jcr.Node;
  13 import javax.jcr.NodeIterator;
  14 import javax.jcr.Property;
  15 import javax.jcr.RepositoryException;
  16 import javax.jcr.Session;
  17 import javax.jcr.observation.Event;
  18 import javax.jcr.observation.EventIterator;
  19 import javax.jcr.observation.EventListener;
  20
  21 import org.apache.commons.io.IOUtils;
  22 import org.argeo.ArgeoException;
  23 import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  24 import org.argeo.eclipse.ui.jcr.NodesWrapper;
  25 import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  26 import org.argeo.eclipse.ui.jcr.WrappedNode;
  27 import org.argeo.slc.SlcException;
  28 import org.argeo.slc.client.ui.ClientUiPlugin;
  29 import org.argeo.slc.client.ui.controllers.ProcessController;
  30 import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider;
  31 import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider.FlowNode;
  32 import org.argeo.slc.jcr.SlcJcrConstants;
  33 import org.argeo.slc.jcr.SlcNames;
  34 import org.argeo.slc.jcr.SlcTypes;
  35 import org.argeo.slc.process.RealizedFlow;
  36 import org.argeo.slc.process.SlcExecution;
  37 import org.eclipse.jface.viewers.ColumnViewerToolTipSupport;
  38 import org.eclipse.jface.viewers.DoubleClickEvent;
  39 import org.eclipse.jface.viewers.IDoubleClickListener;
  40 import org.eclipse.jface.viewers.IStructuredSelection;
  41 import org.eclipse.jface.viewers.ITableLabelProvider;
  42 import org.eclipse.jface.viewers.TreeViewer;
  43 import org.eclipse.swt.SWT;
  44 import org.eclipse.swt.dnd.DND;
  45 import org.eclipse.swt.dnd.DragSourceEvent;
  46 import org.eclipse.swt.dnd.DragSourceListener;
  47 import org.eclipse.swt.dnd.TextTransfer;
  48 import org.eclipse.swt.dnd.Transfer;
  49 import org.eclipse.swt.graphics.Image;
  50 import org.eclipse.swt.widgets.Composite;
  51 import org.eclipse.ui.part.ViewPart;
  52
  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 ProcessController processController;
  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                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  78                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  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                         if (node.isNodeType(SlcTypes.SLC_AGENT_PROXY)) {
 117                                 List<AgentNodesWrapper> wrappers = new ArrayList<AgentNodesWrapper>();
 118                                 for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
 119                                         wrappers.add(new AgentNodesWrapper(nit.nextNode()));
 120                                 }
 121                                 return wrappers.toArray();
 122                         }
 123                         return super.getChildren(node);
 124                 }
 125
 126                 @Override
 127                 protected Object[] sort(Object parent, Object[] children) {
 128                         Object[] sorted = new Object[children.length];
 129                         System.arraycopy(children, 0, sorted, 0, children.length);
 130                         Arrays.sort(sorted, new ViewComparator());
 131                         return sorted;
 132                 }
 133         }
 134
 135         static class ViewComparator implements Comparator<Object> {
 136
 137                 public int compare(Object o1, Object o2) {
 138                         try {
 139                                 if (o1 instanceof Node && o2 instanceof Node) {
 140                                         Node node1 = (Node) o1;
 141                                         Node node2 = (Node) o2;
 142                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 143                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 144                                                 return node1.getName().compareTo(node2.getName());
 145                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 146                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 147                                                 return 1;
 148                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 149                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 150                                                 return -1;
 151                                         } else {
 152                                                 // TODO: check title
 153                                                 return node1.getName().compareTo(node2.getName());
 154                                         }
 155                                 }
 156                         } catch (RepositoryException e) {
 157                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 158                                                 e);
 159                         }
 160                         return 0;
 161                 }
 162
 163         }
 164
 165         /** Wraps the execution modules of an agent. */
 166         static class AgentNodesWrapper extends NodesWrapper {
 167
 168                 public AgentNodesWrapper(Node node) {
 169                         super(node);
 170                 }
 171
 172                 protected List<WrappedNode> getWrappedNodes()
 173                                 throws RepositoryException {
 174                         List<WrappedNode> children = new ArrayList<WrappedNode>();
 175                         Node executionModules = getNode().getNode(
 176                                         SlcNames.SLC_EXECUTION_MODULES);
 177                         for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 178                                 for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 179                                                 .hasNext();) {
 180                                         children.add(new WrappedNode(this, nitVersions.nextNode()));
 181                                 }
 182                         }
 183                         return children;
 184                 }
 185
 186         }
 187
 188         class VmAgentObserver implements EventListener {
 189
 190                 public void onEvent(EventIterator events) {
 191                         viewer.refresh();
 192                 }
 193
 194         }
 195
 196         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 197                         ITableLabelProvider {
 198                 public String getColumnText(Object obj, int index) {
 199                         return getText(obj);
 200                 }
 201
 202                 public Image getColumnImage(Object obj, int index) {
 203                         return getImage(obj);
 204                 }
 205
 206                 public Image getImage(Node node) throws RepositoryException {
 207                         if (node.getParent().isNodeType(SlcTypes.SLC_AGENT_PROXY))
 208                                 return ClientUiPlugin.getDefault().getImageRegistry()
 209                                                 .get("agent");
 210                         else if (node.isNodeType(SlcTypes.SLC_MODULE))
 211                                 return ClientUiPlugin.getDefault().getImageRegistry()
 212                                                 .get("executionModule");
 213                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 214                                 return ClientUiPlugin.getDefault().getImageRegistry()
 215                                                 .get("flow");
 216                         else
 217                                 return ClientUiPlugin.getDefault().getImageRegistry()
 218                                                 .get("folder");
 219                 }
 220
 221                 public String getToolTipText(Node node) throws RepositoryException {
 222                         if (node.isNodeType(SlcTypes.SLC_MODULE)
 223                                         && node.hasProperty(Property.JCR_DESCRIPTION))
 224                                 return node.getProperty(Property.JCR_DESCRIPTION).getString();
 225                         return super.getToolTipText(node);
 226                 }
 227
 228         }
 229
 230         class ViewDoubleClickListener implements IDoubleClickListener {
 231                 public void doubleClick(DoubleClickEvent evt) {
 232                         Object obj = ((IStructuredSelection) evt.getSelection())
 233                                         .getFirstElement();
 234                         if (obj instanceof ExecutionModulesContentProvider.FlowNode) {
 235                                 ExecutionModulesContentProvider.FlowNode fn = (ExecutionModulesContentProvider.FlowNode) obj;
 236
 237                                 List<RealizedFlow> realizedFlows = new ArrayList<RealizedFlow>();
 238                                 RealizedFlow realizedFlow = new RealizedFlow();
 239                                 realizedFlow.setModuleName(fn.getExecutionModuleNode()
 240                                                 .getDescriptor().getName());
 241                                 realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 242                                                 .getDescriptor().getVersion());
 243                                 realizedFlow.setFlowDescriptor(fn.getExecutionModuleNode()
 244                                                 .getFlowDescriptors().get(fn.getFlowName()));
 245                                 realizedFlows.add(realizedFlow);
 246
 247                                 SlcExecution slcExecution = new SlcExecution();
 248                                 slcExecution.setUuid(UUID.randomUUID().toString());
 249                                 slcExecution.setRealizedFlows(realizedFlows);
 250                                 slcExecution.setHost(fn.getExecutionModuleNode().getAgentNode()
 251                                                 .getAgent().toString());
 252                                 processController.execute(fn.getExecutionModuleNode()
 253                                                 .getAgentNode().getAgent(), slcExecution);
 254                         }
 255                 }
 256
 257         }
 258
 259         class ViewDragListener implements DragSourceListener {
 260
 261                 public void dragStart(DragSourceEvent event) {
 262                         System.out.println("Start Drag");
 263                 }
 264
 265                 public void dragSetData(DragSourceEvent event) {
 266
 267                         // System.out.println("dragSetData: " + event);
 268
 269                         IStructuredSelection selection = (IStructuredSelection) viewer
 270                                         .getSelection();
 271                         if (selection.getFirstElement() instanceof ExecutionModulesContentProvider.FlowNode) {
 272
 273                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 274                                         ExecutionModulesContentProvider.FlowNode flowNode = (ExecutionModulesContentProvider.FlowNode) selection
 275                                                         .getFirstElement();
 276
 277                                         Properties props = new Properties();
 278                                         flowNodeAsProperties(props, flowNode);
 279                                         props.setProperty("agentId", flowNode
 280                                                         .getExecutionModuleNode().getAgentNode().getAgent()
 281                                                         .getAgentUuid());
 282                                         props.setProperty("host", flowNode.getExecutionModuleNode()
 283                                                         .getAgentNode().getAgent().toString());
 284
 285                                         ByteArrayOutputStream out = new ByteArrayOutputStream();
 286                                         try {
 287                                                 props.store(out, "");
 288                                                 event.data = new String(out.toByteArray());
 289                                         } catch (IOException e) {
 290                                                 throw new SlcException(
 291                                                                 "Cannot transform realized flow", e);
 292                                         } finally {
 293                                                 IOUtils.closeQuietly(out);
 294                                         }
 295                                 }
 296                         }
 297                 }
 298
 299                 public void dragFinished(DragSourceEvent event) {
 300                         System.out.println("Finished Drag");
 301                 }
 302
 303                 protected void flowNodeAsProperties(Properties props, FlowNode fn) {
 304
 305                         RealizedFlow realizedFlow = new RealizedFlow();
 306                         realizedFlow.setModuleName(fn.getExecutionModuleNode()
 307                                         .getDescriptor().getName());
 308                         realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 309                                         .getDescriptor().getVersion());
 310                         realizedFlow.setFlowDescriptor(fn.getExecutionFlowDescriptor());
 311
 312                         // As we want to have the effective ExecutionSpec and not a
 313                         // reference; we store it at the RealizeFlow level : thus the
 314                         // marshaller will store the object and not only a reference.
 315                         realizedFlow.setExecutionSpec(fn.getExecutionFlowDescriptor()
 316                                         .getExecutionSpec());
 317
 318                         // props.setProperty("RealizedFlowAsXml",
 319                         // oxmBean.marshal(realizedFlow));
 320                         // System.out
 321                         // .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
 322
 323                 }
 324
 325         }
 326
 327         public void setProcessController(ProcessController processController) {
 328                 this.processController = processController;
 329         }
 330
 331         public void setSession(Session session) {
 332                 this.session = session;
 333         }
 334
 335 }