cms/org.argeo.slc.client.ui/src/org/argeo/slc/client/ui/views/JcrProcessListView.java

   1 package org.argeo.slc.client.ui.views;
   2
   3 import java.text.DateFormat;
   4 import java.text.SimpleDateFormat;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7
   8 import javax.jcr.Node;
   9 import javax.jcr.NodeIterator;
  10 import javax.jcr.Property;
  11 import javax.jcr.Repository;
  12 import javax.jcr.RepositoryException;
  13 import javax.jcr.Session;
  14 import javax.jcr.observation.Event;
  15 import javax.jcr.observation.EventListener;
  16 import javax.jcr.observation.ObservationManager;
  17 import javax.jcr.query.Query;
  18
  19 import org.argeo.api.NodeConstants;
  20 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  21 import org.argeo.jcr.JcrUtils;
  22 import org.argeo.slc.SlcException;
  23 import org.argeo.slc.SlcNames;
  24 import org.argeo.slc.SlcTypes;
  25 import org.argeo.slc.client.ui.ClientUiPlugin;
  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.ExecutionProcess;
  30 import org.argeo.slc.jcr.SlcJcrUtils;
  31 import org.eclipse.jface.viewers.ColumnLabelProvider;
  32 import org.eclipse.jface.viewers.DoubleClickEvent;
  33 import org.eclipse.jface.viewers.IDoubleClickListener;
  34 import org.eclipse.jface.viewers.IStructuredContentProvider;
  35 import org.eclipse.jface.viewers.IStructuredSelection;
  36 import org.eclipse.jface.viewers.ITableLabelProvider;
  37 import org.eclipse.jface.viewers.TableViewer;
  38 import org.eclipse.jface.viewers.Viewer;
  39 import org.eclipse.rap.rwt.service.ServerPushSession;
  40 import org.eclipse.swt.SWT;
  41 import org.eclipse.swt.graphics.Image;
  42 import org.eclipse.swt.widgets.Composite;
  43 import org.eclipse.swt.widgets.Table;
  44 import org.eclipse.swt.widgets.TableColumn;
  45 import org.eclipse.ui.IWorkbenchPage;
  46 import org.eclipse.ui.PlatformUI;
  47 import org.eclipse.ui.part.ViewPart;
  48
  49 /** Displays processes. */
  50 public class JcrProcessListView extends ViewPart {
  51         public static final String ID = ClientUiPlugin.ID + ".jcrProcessListView";
  52
  53         private TableViewer viewer;
  54         private ServerPushSession pushSession;
  55
  56         private Repository repository;
  57         private Session session;
  58
  59         private EventListener processesObserver;
  60
  61         private DateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss");
  62         private Integer queryLimit = 2000;
  63
  64         public void createPartControl(Composite parent) {
  65                 pushSession = new ServerPushSession();
  66                 pushSession.start();
  67                 try {
  68                         session = repository.login(NodeConstants.HOME_WORKSPACE);
  69                 } catch (RepositoryException re) {
  70                         throw new SlcException("Unable to log in Repository " + repository, re);
  71                 }
  72                 Table table = createTable(parent);
  73                 viewer = new TableViewer(table);
  74                 viewer.setLabelProvider(new LabelProvider());
  75                 viewer.setContentProvider(new ContentProvider());
  76                 viewer.setInput(getViewSite());
  77                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  78
  79                 processesObserver = new AsyncUiEventListener(viewer.getTable().getDisplay()) {
  80                         protected void onEventInUiThread(List<Event> events) {
  81                                 // TODO optimize by updating only the changed process
  82                                 viewer.refresh();
  83                         }
  84                 };
  85                 try {
  86                         ObservationManager observationManager = session.getWorkspace().getObservationManager();
  87                         observationManager.addEventListener(processesObserver,
  88                                         Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_CHANGED,
  89                                         SlcJcrUtils.getSlcProcessesBasePath(session), true, null, null, false);
  90                 } catch (RepositoryException e) {
  91                         throw new SlcException("Cannot register listeners", e);
  92                 }
  93
  94         }
  95
  96         protected Table createTable(Composite parent) {
  97                 int style = SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION;
  98                 // does not function with RAP, commented for the time being
  99                 // | SWT.HIDE_SELECTION;
 100
 101                 Table table = new Table(parent, style);
 102
 103                 table.setLinesVisible(true);
 104                 table.setHeaderVisible(true);
 105
 106                 TableColumn column = new TableColumn(table, SWT.LEFT, 0);
 107                 column.setText("Date");
 108                 column.setWidth(200);
 109
 110                 column = new TableColumn(table, SWT.LEFT, 1);
 111                 column.setText("Host");
 112                 column.setWidth(100);
 113
 114                 column = new TableColumn(table, SWT.LEFT, 2);
 115                 column.setText("Id");
 116                 column.setWidth(300);
 117
 118                 column = new TableColumn(table, SWT.LEFT, 3);
 119                 column.setText("Status");
 120                 column.setWidth(100);
 121
 122                 return table;
 123         }
 124
 125         public void setFocus() {
 126                 viewer.getControl().setFocus();
 127         }
 128
 129         class ContentProvider implements IStructuredContentProvider {
 130
 131                 public Object[] getElements(Object inputElement) {
 132                         try {
 133                                 // TODO filter, optimize with virtual table, ...
 134                                 String sql = "SELECT * from [slc:process] ORDER BY [jcr:lastModified] DESC";
 135                                 Query query = session.getWorkspace().getQueryManager().createQuery(sql, Query.JCR_SQL2);
 136                                 // TODO paging
 137                                 query.setLimit(queryLimit);
 138                                 List<Node> nodes = new ArrayList<Node>();
 139                                 for (NodeIterator nit = query.execute().getNodes(); nit.hasNext();) {
 140                                         nodes.add(nit.nextNode());
 141                                 }
 142                                 return nodes.toArray();
 143                         } catch (RepositoryException e) {
 144                                 throw new SlcException("Cannot retrieve processes", e);
 145                         }
 146                 }
 147
 148                 public void dispose() {
 149                 }
 150
 151                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 152                 }
 153
 154         }
 155
 156         class LabelProvider extends ColumnLabelProvider implements ITableLabelProvider {
 157
 158                 public Image getColumnImage(Object obj, int columnIndex) {
 159                         if (columnIndex != 0)
 160                                 return null;
 161                         try {
 162                                 Node node = (Node) obj;
 163                                 String status = node.getProperty(SlcNames.SLC_STATUS).getString();
 164                                 if (status.equals(ExecutionProcess.NEW) || status.equals(ExecutionProcess.INITIALIZED)
 165                                                 || status.equals(ExecutionProcess.SCHEDULED))
 166                                         return SlcImages.PROCESS_SCHEDULED;
 167                                 else if (status.equals(ExecutionProcess.ERROR) || status.equals(ExecutionProcess.UNKOWN))
 168                                         return SlcImages.PROCESS_ERROR;
 169                                 else if (status.equals(ExecutionProcess.COMPLETED))
 170                                         return SlcImages.PROCESS_COMPLETED;
 171                                 else if (status.equals(ExecutionProcess.RUNNING))
 172                                         return SlcImages.PROCESS_RUNNING;
 173                                 else if (status.equals(ExecutionProcess.KILLED))
 174                                         return SlcImages.PROCESS_ERROR;
 175                                 else
 176                                         throw new SlcException("Unkown status " + status);
 177                         } catch (RepositoryException e) {
 178                                 throw new SlcException("Cannot get column text", e);
 179                         }
 180                 }
 181
 182                 public String getColumnText(Object obj, int index) {
 183                         try {
 184                                 Node node = (Node) obj;
 185                                 switch (index) {
 186
 187                                 case 0:
 188                                         return dateFormat.format(node.getProperty(Property.JCR_LAST_MODIFIED).getDate().getTime());
 189                                 case 1:
 190                                         return "local";
 191                                 case 2:
 192                                         return node.getProperty(SlcNames.SLC_UUID).getString();
 193                                 case 3:
 194                                         return node.getProperty(SlcNames.SLC_STATUS).getString();
 195                                 }
 196                                 return getText(obj);
 197                         } catch (RepositoryException e) {
 198                                 throw new SlcException("Cannot get column text", e);
 199                         }
 200                 }
 201
 202         }
 203
 204         class ViewDoubleClickListener implements IDoubleClickListener {
 205                 public void doubleClick(DoubleClickEvent evt) {
 206                         Object obj = ((IStructuredSelection) evt.getSelection()).getFirstElement();
 207                         try {
 208                                 if (obj instanceof Node) {
 209                                         Node node = (Node) obj;
 210                                         if (node.isNodeType(SlcTypes.SLC_PROCESS)) {
 211                                                 IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
 212                                                                 .getActivePage();
 213                                                 activePage.openEditor(new ProcessEditorInput(node.getPath()), ProcessEditor.ID);
 214                                         }
 215                                 }
 216                         } catch (Exception e) {
 217                                 throw new SlcException("Cannot open " + obj, e);
 218                         }
 219                 }
 220
 221         }
 222
 223         public void dispose() {
 224                 JcrUtils.unregisterQuietly(session.getWorkspace(), processesObserver);
 225                 JcrUtils.logoutQuietly(session);
 226                 if (pushSession != null)
 227                         pushSession.stop();
 228                 super.dispose();
 229         }
 230
 231         public void setRepository(Repository repository) {
 232                 this.repository = repository;
 233         }
 234
 235 }