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.RepositoryException;
  15 import javax.jcr.Session;
  16 import javax.jcr.observation.Event;
  17 import javax.jcr.observation.EventIterator;
  18 import javax.jcr.observation.EventListener;
  19
  20 import org.apache.commons.io.IOUtils;
  21 import org.apache.commons.logging.Log;
  22 import org.apache.commons.logging.LogFactory;
  23 import org.argeo.ArgeoException;
  24 import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  25 import org.argeo.eclipse.ui.jcr.NodesWrapper;
  26 import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  27 import org.argeo.eclipse.ui.jcr.WrappedNode;
  28 import org.argeo.slc.SlcException;
  29 import org.argeo.slc.client.ui.ClientUiPlugin;
  30 import org.argeo.slc.client.ui.controllers.ProcessController;
  31 import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider;
  32 import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider.FlowNode;
  33 import org.argeo.slc.jcr.SlcJcrConstants;
  34 import org.argeo.slc.jcr.SlcNames;
  35 import org.argeo.slc.jcr.SlcTypes;
  36 import org.argeo.slc.process.RealizedFlow;
  37 import org.argeo.slc.process.SlcExecution;
  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
  69                 ViewContentProvider contentProvider = new ViewContentProvider(session);
  70
  71                 viewer.setContentProvider(contentProvider);
  72                 viewer.setLabelProvider(new ViewLabelProvider());
  73                 viewer.setInput(getViewSite());
  74                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  75                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  76                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  77                 viewer.addDragSupport(operations, tt, new ViewDragListener());
  78
  79                 try {
  80                         session.getWorkspace()
  81                                         .getObservationManager()
  82                                         .addEventListener(
  83                                                         new VmAgentObserver(),
  84                                                         Event.NODE_ADDED | Event.NODE_REMOVED
  85                                                                         | Event.NODE_MOVED,
  86                                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null,
  87                                                         null, false);
  88                 } catch (RepositoryException e) {
  89                         throw new SlcException("Cannot add observer", e);
  90                 }
  91         }
  92
  93         public void setFocus() {
  94                 viewer.getControl().setFocus();
  95         }
  96
  97         public TreeViewer getViewer() {
  98                 return viewer;
  99         }
 100
 101         public void refreshView() {
 102                 viewer.setInput(getViewSite());
 103         }
 104
 105         class ViewContentProvider extends SimpleNodeContentProvider {
 106
 107                 public ViewContentProvider(Session session) {
 108                         super(session,
 109                                         new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
 110                 }
 111
 112                 @Override
 113                 protected Object[] getChildren(Node node) throws RepositoryException {
 114                         if (node.isNodeType(SlcTypes.SLC_AGENT_PROXY)) {
 115                                 List<AgentNodesWrapper> wrappers = new ArrayList<AgentNodesWrapper>();
 116                                 for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
 117                                         wrappers.add(new AgentNodesWrapper(nit.nextNode()));
 118                                 }
 119                                 return wrappers.toArray();
 120                         }
 121                         return super.getChildren(node);
 122                 }
 123
 124                 @Override
 125                 protected Object[] sort(Object parent, Object[] children) {
 126                         Object[] sorted = new Object[children.length];
 127                         System.arraycopy(children, 0, sorted, 0, children.length);
 128                         Arrays.sort(sorted, new ViewComparator());
 129                         return sorted;
 130                 }
 131         }
 132
 133         static class ViewComparator implements Comparator<Object> {
 134
 135                 public int compare(Object o1, Object o2) {
 136                         try {
 137                                 if (o1 instanceof Node && o2 instanceof Node) {
 138                                         Node node1 = (Node) o1;
 139                                         Node node2 = (Node) o2;
 140                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 141                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 142                                                 return node1.getName().compareTo(node2.getName());
 143                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 144                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 145                                                 return 1;
 146                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 147                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 148                                                 return -1;
 149                                         } else {
 150                                                 // TODO: check title
 151                                                 return node1.getName().compareTo(node2.getName());
 152                                         }
 153                                 }
 154                         } catch (RepositoryException e) {
 155                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 156                                                 e);
 157                         }
 158                         return 0;
 159                 }
 160
 161         }
 162
 163         /** Wraps the execution modules of an agent. */
 164         static class AgentNodesWrapper extends NodesWrapper {
 165
 166                 public AgentNodesWrapper(Node node) {
 167                         super(node);
 168                 }
 169
 170                 protected List<WrappedNode> getWrappedNodes()
 171                                 throws RepositoryException {
 172                         List<WrappedNode> children = new ArrayList<WrappedNode>();
 173                         Node executionModules = getNode().getNode(
 174                                         SlcNames.SLC_EXECUTION_MODULES);
 175                         for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 176                                 for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 177                                                 .hasNext();) {
 178                                         children.add(new WrappedNode(this, nitVersions.nextNode()));
 179                                 }
 180                         }
 181                         return children;
 182                 }
 183
 184         }
 185
 186         class VmAgentObserver implements EventListener {
 187
 188                 public void onEvent(EventIterator events) {
 189                         viewer.refresh();
 190                 }
 191
 192         }
 193
 194         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 195                         ITableLabelProvider {
 196                 public String getColumnText(Object obj, int index) {
 197                         return getText(obj);
 198                 }
 199
 200                 public Image getColumnImage(Object obj, int index) {
 201                         return getImage(obj);
 202                 }
 203
 204                 public Image getImage(Node node) throws RepositoryException {
 205                         if (node.getParent().isNodeType(SlcTypes.SLC_AGENT_PROXY))
 206                                 return ClientUiPlugin.getDefault().getImageRegistry()
 207                                                 .get("agent");
 208                         else if (node.isNodeType(SlcTypes.SLC_MODULE))
 209                                 return ClientUiPlugin.getDefault().getImageRegistry()
 210                                                 .get("executionModule");
 211                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 212                                 return ClientUiPlugin.getDefault().getImageRegistry()
 213                                                 .get("flow");
 214                         else
 215                                 return ClientUiPlugin.getDefault().getImageRegistry()
 216                                                 .get("folder");
 217                 }
 218         }
 219
 220         class ViewDoubleClickListener implements IDoubleClickListener {
 221                 public void doubleClick(DoubleClickEvent evt) {
 222                         Object obj = ((IStructuredSelection) evt.getSelection())
 223                                         .getFirstElement();
 224                         if (obj instanceof ExecutionModulesContentProvider.FlowNode) {
 225                                 ExecutionModulesContentProvider.FlowNode fn = (ExecutionModulesContentProvider.FlowNode) obj;
 226
 227                                 List<RealizedFlow> realizedFlows = new ArrayList<RealizedFlow>();
 228                                 RealizedFlow realizedFlow = new RealizedFlow();
 229                                 realizedFlow.setModuleName(fn.getExecutionModuleNode()
 230                                                 .getDescriptor().getName());
 231                                 realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 232                                                 .getDescriptor().getVersion());
 233                                 realizedFlow.setFlowDescriptor(fn.getExecutionModuleNode()
 234                                                 .getFlowDescriptors().get(fn.getFlowName()));
 235                                 realizedFlows.add(realizedFlow);
 236
 237                                 SlcExecution slcExecution = new SlcExecution();
 238                                 slcExecution.setUuid(UUID.randomUUID().toString());
 239                                 slcExecution.setRealizedFlows(realizedFlows);
 240                                 slcExecution.setHost(fn.getExecutionModuleNode().getAgentNode()
 241                                                 .getAgent().toString());
 242                                 processController.execute(fn.getExecutionModuleNode()
 243                                                 .getAgentNode().getAgent(), slcExecution);
 244                         }
 245                 }
 246
 247         }
 248
 249         class ViewDragListener implements DragSourceListener {
 250
 251                 public void dragStart(DragSourceEvent event) {
 252                         System.out.println("Start Drag");
 253                 }
 254
 255                 public void dragSetData(DragSourceEvent event) {
 256
 257                         // System.out.println("dragSetData: " + event);
 258
 259                         IStructuredSelection selection = (IStructuredSelection) viewer
 260                                         .getSelection();
 261                         if (selection.getFirstElement() instanceof ExecutionModulesContentProvider.FlowNode) {
 262
 263                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 264                                         ExecutionModulesContentProvider.FlowNode flowNode = (ExecutionModulesContentProvider.FlowNode) selection
 265                                                         .getFirstElement();
 266
 267                                         Properties props = new Properties();
 268                                         flowNodeAsProperties(props, flowNode);
 269                                         props.setProperty("agentId", flowNode
 270                                                         .getExecutionModuleNode().getAgentNode().getAgent()
 271                                                         .getAgentUuid());
 272                                         props.setProperty("host", flowNode.getExecutionModuleNode()
 273                                                         .getAgentNode().getAgent().toString());
 274
 275                                         ByteArrayOutputStream out = new ByteArrayOutputStream();
 276                                         try {
 277                                                 props.store(out, "");
 278                                                 event.data = new String(out.toByteArray());
 279                                         } catch (IOException e) {
 280                                                 throw new SlcException(
 281                                                                 "Cannot transform realized flow", e);
 282                                         } finally {
 283                                                 IOUtils.closeQuietly(out);
 284                                         }
 285                                 }
 286                         }
 287                 }
 288
 289                 public void dragFinished(DragSourceEvent event) {
 290                         System.out.println("Finished Drag");
 291                 }
 292
 293                 protected void flowNodeAsProperties(Properties props, FlowNode fn) {
 294
 295                         RealizedFlow realizedFlow = new RealizedFlow();
 296                         realizedFlow.setModuleName(fn.getExecutionModuleNode()
 297                                         .getDescriptor().getName());
 298                         realizedFlow.setModuleVersion(fn.getExecutionModuleNode()
 299                                         .getDescriptor().getVersion());
 300                         realizedFlow.setFlowDescriptor(fn.getExecutionFlowDescriptor());
 301
 302                         // As we want to have the effective ExecutionSpec and not a
 303                         // reference; we store it at the RealizeFlow level : thus the
 304                         // marshaller will store the object and not only a reference.
 305                         realizedFlow.setExecutionSpec(fn.getExecutionFlowDescriptor()
 306                                         .getExecutionSpec());
 307
 308                         // props.setProperty("RealizedFlowAsXml",
 309                         // oxmBean.marshal(realizedFlow));
 310                         // System.out
 311                         // .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
 312
 313                 }
 314
 315         }
 316
 317         public void setProcessController(ProcessController processController) {
 318                 this.processController = processController;
 319         }
 320
 321         public void setSession(Session session) {
 322                 this.session = session;
 323         }
 324
 325 }