1 package org
.argeo
.slc
.client
.ui
.views
;
3 import java
.util
.ArrayList
;
4 import java
.util
.Arrays
;
5 import java
.util
.Comparator
;
7 import java
.util
.Properties
;
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
;
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
;
52 public class JcrExecutionModulesView
extends ViewPart
implements SlcTypes
,
54 private final static Log log
= LogFactory
55 .getLog(JcrExecutionModulesView
.class);
57 public static final String ID
= "org.argeo.slc.client.ui.jcrExecutionModulesView";
59 private TreeViewer viewer
;
61 private Session session
;
63 private ProcessController processController
;
65 public void createPartControl(Composite parent
) {
66 viewer
= new TreeViewer(parent
, SWT
.MULTI
| SWT
.H_SCROLL
| SWT
.V_SCROLL
);
67 ColumnViewerToolTipSupport
.enableFor(viewer
);
69 ViewContentProvider contentProvider
= new ViewContentProvider(session
);
71 viewer
.setContentProvider(contentProvider
);
72 final ViewLabelProvider viewLabelProvider
= new ViewLabelProvider();
73 viewer
.setLabelProvider(viewLabelProvider
);
74 viewer
.setInput(getViewSite());
75 viewer
.addDoubleClickListener(new ViewDoubleClickListener());
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());
83 session
.getWorkspace()
84 .getObservationManager()
86 new VmAgentObserver(),
87 Event
.NODE_ADDED
| Event
.NODE_REMOVED
89 SlcJcrConstants
.VM_AGENT_FACTORY_PATH
, true, null,
91 } catch (RepositoryException e
) {
92 throw new SlcException("Cannot add observer", e
);
96 public void setFocus() {
97 viewer
.getControl().setFocus();
100 public TreeViewer
getViewer() {
104 public void refreshView() {
105 viewer
.setInput(getViewSite());
108 class ViewContentProvider
extends SimpleNodeContentProvider
{
110 public ViewContentProvider(Session session
) {
112 new String
[] { SlcJcrConstants
.VM_AGENT_FACTORY_PATH
});
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()));
122 return wrappers
.toArray();
124 return super.getChildren(node
);
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());
136 static class ViewComparator
implements Comparator
<Object
> {
138 public int compare(Object o1
, Object o2
) {
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
)) {
149 } else if (!node1
.isNodeType(SLC_EXECUTION_FLOW
)
150 && node2
.isNodeType(SLC_EXECUTION_FLOW
)) {
154 return node1
.getName().compareTo(node2
.getName());
157 } catch (RepositoryException e
) {
158 throw new ArgeoException("Cannot compare " + o1
+ " and " + o2
,
166 /** Wraps the execution modules of an agent. */
167 static class AgentNodesWrapper
extends NodesWrapper
{
169 public AgentNodesWrapper(Node node
) {
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
181 children
.add(new WrappedNode(this, nitVersions
.nextNode()));
189 class VmAgentObserver
implements EventListener
{
191 public void onEvent(EventIterator events
) {
197 class ViewLabelProvider
extends DefaultNodeLabelProvider
implements
198 ITableLabelProvider
{
199 public String
getColumnText(Object obj
, int index
) {
203 public Image
getColumnImage(Object obj
, int index
) {
204 return getImage(obj
);
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
;
215 return SlcImages
.FOLDER
;
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
);
227 class ViewDoubleClickListener
implements IDoubleClickListener
{
228 public void doubleClick(DoubleClickEvent evt
) {
229 Object obj
= ((IStructuredSelection
) evt
.getSelection())
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());
239 .getActiveWorkbenchWindow()
242 new ProcessEditorInput(paths
, true),
246 } catch (Exception e
) {
247 throw new SlcException("Cannot open " + obj
, e
);
250 // if (obj instanceof ExecutionModulesContentProvider.FlowNode) {
251 // ExecutionModulesContentProvider.FlowNode fn =
252 // (ExecutionModulesContentProvider.FlowNode) obj;
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);
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);
276 class ViewDragListener
extends DragSourceAdapter
{
278 public void dragStart(DragSourceEvent event
) {
279 if (log
.isDebugEnabled())
280 log
.debug("Start Drag " + event
);
281 super.dragStart(event
);
284 public void dragSetData(DragSourceEvent event
) {
286 // System.out.println("dragSetData: " + event);
288 IStructuredSelection selection
= (IStructuredSelection
) viewer
290 if (selection
.getFirstElement() instanceof Node
) {
291 Node node
= (Node
) selection
.getFirstElement();
293 // if (node.isNodeType(SLC_EXECUTION_FLOW)) {
294 // if (EditorInputTransfer.getInstance().isSupportedType(
295 // event.dataType)) {
296 // ProcessEditorInput pei = new ProcessEditorInput(
298 // EditorInputData eid = EditorInputTransfer
299 // .createEditorInputData(ProcessEditor.ID,
301 // event.data = new EditorInputTransfer.EditorInputData[] { eid
306 // } catch (RepositoryException e1) {
307 // throw new SlcException("Cannot drag " + node, e1);
310 if (TextTransfer
.getInstance().isSupportedType(event
.dataType
)) {
312 event
.data
= node
.getPath();
313 } catch (RepositoryException e1
) {
314 // TODO Auto-generated catch block
315 e1
.printStackTrace();
318 // // ExecutionModulesContentProvider.FlowNode flowNode =
319 // (ExecutionModulesContentProvider.FlowNode) selection
320 // // .getFirstElement();
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());
331 // // ByteArrayOutputStream out = new
332 // ByteArrayOutputStream();
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);
340 // // IOUtils.closeQuietly(out);
346 public void dragFinished(DragSourceEvent event
) {
347 if (log
.isDebugEnabled())
348 log
.debug("Finished Drag " + event
);
351 protected void flowNodeAsProperties(Properties props
, FlowNode fn
) {
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());
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());
366 // props.setProperty("RealizedFlowAsXml",
367 // oxmBean.marshal(realizedFlow));
369 // .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
375 public void setProcessController(ProcessController processController
) {
376 this.processController
= processController
;
379 public void setSession(Session session
) {
380 this.session
= session
;