eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/editors/ProcessEditor.java

   1 package org.argeo.slc.client.ui.editors;
   2
   3 import java.util.HashMap;
   4 import java.util.List;
   5 import java.util.Map;
   6 import java.util.UUID;
   7
   8 import javax.jcr.Node;
   9 import javax.jcr.NodeIterator;
  10 import javax.jcr.RepositoryException;
  11 import javax.jcr.Session;
  12
  13 import org.argeo.eclipse.ui.ErrorFeedback;
  14 import org.argeo.jcr.JcrUtils;
  15 import org.argeo.slc.SlcException;
  16 import org.argeo.slc.client.ui.ClientUiPlugin;
  17 import org.argeo.slc.client.ui.controllers.ProcessController;
  18 import org.argeo.slc.execution.ExecutionModulesManager;
  19 import org.argeo.slc.execution.ExecutionProcess;
  20 import org.argeo.slc.execution.ExecutionProcessNotifier;
  21 import org.argeo.slc.execution.ExecutionStep;
  22 import org.argeo.slc.jcr.SlcJcrUtils;
  23 import org.argeo.slc.jcr.SlcNames;
  24 import org.argeo.slc.jcr.SlcTypes;
  25 import org.eclipse.core.runtime.IProgressMonitor;
  26 import org.eclipse.ui.IEditorInput;
  27 import org.eclipse.ui.IEditorSite;
  28 import org.eclipse.ui.IWorkbenchPage;
  29 import org.eclipse.ui.PartInitException;
  30 import org.eclipse.ui.PlatformUI;
  31 import org.eclipse.ui.forms.editor.FormEditor;
  32
  33 /** Editor for an execution process. */
  34 public class ProcessEditor extends FormEditor implements
  35                 ExecutionProcessNotifier, SlcTypes, SlcNames {
  36         public final static String ID = ClientUiPlugin.ID + ".processEditor";
  37
  38         private Session session;
  39         private Node processNode;
  40         private ProcessController processController;
  41
  42         private ProcessBuilderPage builderPage;
  43         private ProcessLogPage logPage;
  44
  45         private ExecutionModulesManager modulesManager;
  46
  47         @Override
  48         public void init(IEditorSite site, IEditorInput input)
  49                         throws PartInitException {
  50                 super.init(site, input);
  51                 ProcessEditorInput pei = (ProcessEditorInput) input;
  52                 String processPath = pei.getProcessPath();
  53                 try {
  54                         if (processPath != null) {
  55                                 if (!session.itemExists(processPath))
  56                                         throw new SlcException("Process " + processPath
  57                                                         + " does not exist");
  58                                 processNode = session.getNode(processPath);
  59                         } else {// new
  60                                 processNode = newProcessNode(pei);
  61                         }
  62                         setPartName(processNode.getName());
  63                 } catch (RepositoryException e) {
  64                         throw new SlcException("Cannot initialize editor for " + pei, e);
  65                 }
  66
  67         }
  68
  69         protected Node newProcessNode(ProcessEditorInput pei)
  70                         throws RepositoryException {
  71                 String uuid = UUID.randomUUID().toString();
  72                 String processPath = SlcJcrUtils.createExecutionProcessPath(uuid);
  73                 Node processNode = JcrUtils.mkdirs(session, processPath, SLC_PROCESS);
  74                 processNode.setProperty(SLC_UUID, uuid);
  75                 processNode.setProperty(SLC_STATUS, ExecutionProcess.NEW);
  76                 Node processFlow = processNode.addNode(SLC_FLOW);
  77                 processFlow.addMixin(SLC_REALIZED_FLOW);
  78                 return processNode;
  79         }
  80
  81         @Override
  82         public boolean isDirty() {
  83                 if (getProcessStatus().equals(ExecutionProcess.NEW))
  84                         return true;
  85                 return super.isDirty();
  86         }
  87
  88         protected String getProcessStatus() {
  89                 try {
  90                         return processNode.getProperty(SLC_STATUS).getString();
  91                 } catch (RepositoryException e) {
  92                         throw new SlcException("Cannot retrieve status for " + processNode,
  93                                         e);
  94                 }
  95         }
  96
  97         @Override
  98         public void dispose() {
  99                 JcrUtils.logoutQuietly(session);
 100         }
 101
 102         /** Actually runs the process. */
 103         void process() {
 104                 // the modifications have to be saved before execution
 105                 try {
 106                         processNode.setProperty(SLC_STATUS, ExecutionProcess.SCHEDULED);
 107                 } catch (RepositoryException e) {
 108                         throw new SlcException("Cannot update status of " + processNode, e);
 109                 }
 110                 doSave(null);
 111                 try {
 112                         // show log
 113                         setActivePage(logPage.getId());
 114
 115                         ExecutionProcess process = processController.process(processNode);
 116                         Map<String, String> properties = new HashMap<String, String>();
 117                         properties.put(ExecutionModulesManager.SLC_PROCESS_ID,
 118                                         process.getUuid());
 119                         modulesManager.registerProcessNotifier(this, properties);
 120                 } catch (Exception e) {
 121                         ErrorFeedback.show("Execution of " + processNode + " failed", e);
 122                 }
 123         }
 124
 125         void kill() {
 126                 processController.kill(processNode);
 127         }
 128
 129         /** Opens a new editor with a copy of this process */
 130         void relaunch() {
 131                 try {
 132                         Node duplicatedNode = duplicateProcess();
 133                         IWorkbenchPage activePage = PlatformUI.getWorkbench()
 134                                         .getActiveWorkbenchWindow().getActivePage();
 135                         activePage.openEditor(
 136                                         new ProcessEditorInput(duplicatedNode.getPath()),
 137                                         ProcessEditor.ID);
 138                         close(false);
 139                 } catch (Exception e1) {
 140                         throw new SlcException("Cannot relaunch " + processNode, e1);
 141                 }
 142         }
 143
 144         /** Duplicates the process */
 145         protected Node duplicateProcess() {
 146                 try {
 147                         Session session = processNode.getSession();
 148                         String uuid = UUID.randomUUID().toString();
 149                         String destPath = SlcJcrUtils.createExecutionProcessPath(uuid);
 150                         Node newNode = JcrUtils.mkdirs(session, destPath,
 151                                         SlcTypes.SLC_PROCESS);
 152
 153                         Node rootRealizedFlowNode = newNode.addNode(SLC_FLOW);
 154                         // copy node
 155                         JcrUtils.copy(processNode.getNode(SLC_FLOW), rootRealizedFlowNode);
 156
 157                         newNode.setProperty(SLC_UUID, uuid);
 158                         newNode.setProperty(SLC_STATUS, ExecutionProcess.INITIALIZED);
 159
 160                         // reset realized flow status
 161                         // we just manage one level for the time being
 162                         NodeIterator nit = rootRealizedFlowNode.getNodes(SLC_FLOW);
 163                         while (nit.hasNext()) {
 164                                 nit.nextNode().setProperty(SLC_STATUS,
 165                                                 ExecutionProcess.INITIALIZED);
 166                         }
 167
 168                         session.save();
 169                         return newNode;
 170                 } catch (RepositoryException e) {
 171                         throw new SlcException("Cannot duplicate process", e);
 172                 }
 173         }
 174
 175         @Override
 176         protected void addPages() {
 177                 try {
 178                         builderPage = new ProcessBuilderPage(this, processNode);
 179                         addPage(builderPage);
 180                         firePropertyChange(PROP_DIRTY);
 181                         logPage = new ProcessLogPage(this, processNode);
 182                         addPage(logPage);
 183                 } catch (PartInitException e) {
 184                         throw new SlcException("Cannot add pages", e);
 185                 }
 186
 187         }
 188
 189         @Override
 190         public void doSave(IProgressMonitor monitor) {
 191                 try {
 192                         String status = processNode.getProperty(SLC_STATUS).getString();
 193                         if (status.equals(ExecutionProcess.NEW))
 194                                 processNode.setProperty(SLC_STATUS,
 195                                                 ExecutionProcess.INITIALIZED);
 196                         session.save();
 197                         builderPage.commit(true);
 198                         editorDirtyStateChanged();
 199                 } catch (RepositoryException e) {
 200                         throw new SlcException("Cannot save " + processNode, e);
 201                 } finally {
 202                         JcrUtils.discardQuietly(session);
 203                 }
 204         }
 205
 206         @Override
 207         public void doSaveAs() {
 208         }
 209
 210         @Override
 211         public boolean isSaveAsAllowed() {
 212                 return false;
 213         }
 214
 215         public void updateStatus(ExecutionProcess process, String oldStatus,
 216                         String newStatus) {
 217         }
 218
 219         public void addSteps(ExecutionProcess process, List<ExecutionStep> steps) {
 220                 // logPage.addSteps(steps);
 221         }
 222
 223         /** Expects one session per editor. */
 224         public void setSession(Session session) {
 225                 this.session = session;
 226         }
 227
 228         public void setProcessController(ProcessController processController) {
 229                 this.processController = processController;
 230         }
 231
 232         public void setModulesManager(ExecutionModulesManager modulesManager) {
 233                 this.modulesManager = modulesManager;
 234         }
 235
 236 }