runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrProcessThread.java

   1 /*
   2
   3  * Copyright (C) 2007-2012 Argeo GmbH
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *         http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 package org.argeo.slc.jcr.execution;
  18
  19 import java.util.List;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.RepositoryException;
  23 import javax.jcr.Session;
  24
  25 import org.argeo.ArgeoException;
  26 import org.argeo.jcr.JcrUtils;
  27 import org.argeo.slc.core.execution.ProcessThread;
  28 import org.argeo.slc.execution.ExecutionModulesManager;
  29 import org.argeo.slc.execution.ExecutionProcess;
  30 import org.argeo.slc.execution.RealizedFlow;
  31 import org.argeo.slc.jcr.SlcNames;
  32
  33 /** Where the actual execution takes place */
  34 public class JcrProcessThread extends ProcessThread implements SlcNames {
  35
  36         public JcrProcessThread(ThreadGroup processesThreadGroup,
  37                         ExecutionModulesManager executionModulesManager,
  38                         JcrExecutionProcess process) {
  39                 super(processesThreadGroup, executionModulesManager, process);
  40         }
  41
  42         @Override
  43         protected void process() throws InterruptedException {
  44                 Session session = null;
  45                 try {
  46                         session = getJcrExecutionProcess().getRepository().login();
  47
  48                         List<RealizedFlow> realizedFlows = getProcess().getRealizedFlows();
  49                         for (RealizedFlow realizedFlow : realizedFlows) {
  50                                 Node realizedFlowNode = session
  51                                                 .getNode(((JcrRealizedFlow) realizedFlow).getPath());
  52
  53                                 // set status on realized flow
  54                                 realizedFlowNode.setProperty(SLC_STATUS,
  55                                                 ExecutionProcess.RUNNING);
  56                                 realizedFlowNode.getSession().save();
  57                                 try {
  58                                         //
  59                                         // EXECUTE THE FLOW
  60                                         //
  61                                         execute(realizedFlow, true);
  62
  63                                         // set status on realized flow
  64                                         realizedFlowNode.setProperty(SLC_STATUS,
  65                                                         ExecutionProcess.COMPLETED);
  66                                         realizedFlowNode.getSession().save();
  67                                 } catch (RepositoryException e) {
  68                                         throw e;
  69                                 } catch (InterruptedException e) {
  70                                         // set status on realized flow
  71                                         realizedFlowNode.setProperty(SLC_STATUS,
  72                                                         ExecutionProcess.KILLED);
  73                                         realizedFlowNode.getSession().save();
  74                                         throw e;
  75                                 } catch (RuntimeException e) {
  76                                         // set status on realized flow
  77                                         realizedFlowNode.setProperty(SLC_STATUS,
  78                                                         ExecutionProcess.ERROR);
  79                                         realizedFlowNode.getSession().save();
  80                                         throw e;
  81                                 }
  82                         }
  83                 } catch (RepositoryException e) {
  84                         throw new ArgeoException("Cannot process "
  85                                         + getJcrExecutionProcess().getNodePath(), e);
  86                 } finally {
  87                         JcrUtils.logoutQuietly(session);
  88                 }
  89         }
  90
  91         //
  92         // /** CONFIGURE THE REALIZED FLOWS */
  93         // PROTECTED VOID EXECUTE(NODE REALIZEDFLOWNODE) THROWS REPOSITORYEXCEPTION,
  94         // INTERRUPTEDEXCEPTION {
  95         // IF (REALIZEDFLOWNODE.HASNODE(SLC_ADDRESS)) {
  96         // STRING FLOWPATH = REALIZEDFLOWNODE.GETNODE(SLC_ADDRESS)
  97         // .GETPROPERTY(PROPERTY.JCR_PATH).GETSTRING();
  98         // // TODO: CONVERT TO LOCAL PATH IF REMOTE
  99         //
 100         // NODE FLOWNODE = REALIZEDFLOWNODE.GETSESSION().GETNODE(FLOWPATH);
 101         // STRING FLOWNAME = FLOWNODE.GETPROPERTY(SLC_NAME).GETSTRING();
 102         //
 103         // NODE EXECUTIONMODULENODE = FLOWNODE.GETSESSION().GETNODE(
 104         // SLCJCRUTILS.MODULEPATH(FLOWPATH));
 105         // STRING EXECUTIONMODULENAME = EXECUTIONMODULENODE.GETPROPERTY(
 106         // SLC_NAME).GETSTRING();
 107         // STRING EXECUTIONMODULEVERSION = EXECUTIONMODULENODE.GETPROPERTY(
 108         // SLC_VERSION).GETSTRING();
 109         //
 110         // REALIZEDFLOW REALIZEDFLOW = NEW REALIZEDFLOW();
 111         // REALIZEDFLOW.SETMODULENAME(EXECUTIONMODULENAME);
 112         // REALIZEDFLOW.SETMODULEVERSION(EXECUTIONMODULEVERSION);
 113         //
 114         // // RETRIEVE EXECUTION SPEC
 115         // DEFAULTEXECUTIONSPEC EXECUTIONSPEC = NEW DEFAULTEXECUTIONSPEC();
 116         // MAP<STRING, EXECUTIONSPECATTRIBUTE> ATTRS =
 117         // READEXECUTIONSPECATTRIBUTES(REALIZEDFLOWNODE);
 118         // EXECUTIONSPEC.SETATTRIBUTES(ATTRS);
 119         //
 120         // // SET EXECUTION SPEC NAME
 121         // IF (FLOWNODE.HASPROPERTY(SLCNAMES.SLC_SPEC)) {
 122         // NODE EXECUTIONSPECNODE = FLOWNODE.GETPROPERTY(SLC_SPEC)
 123         // .GETNODE();
 124         // EXECUTIONSPEC.SETBEANNAME(EXECUTIONSPECNODE.GETPROPERTY(
 125         // SLC_NAME).GETSTRING());
 126         // }
 127         //
 128         // // EXPLICITLY RETRIEVE VALUES
 129         // MAP<STRING, OBJECT> VALUES = NEW HASHMAP<STRING, OBJECT>();
 130         // FOR (STRING ATTRNAME : ATTRS.KEYSET()) {
 131         // EXECUTIONSPECATTRIBUTE ATTR = ATTRS.GET(ATTRNAME);
 132         // OBJECT VALUE = ATTR.GETVALUE();
 133         // VALUES.PUT(ATTRNAME, VALUE);
 134         // }
 135         //
 136         // EXECUTIONFLOWDESCRIPTOR EFD = NEW EXECUTIONFLOWDESCRIPTOR(FLOWNAME,
 137         // VALUES, EXECUTIONSPEC);
 138         // REALIZEDFLOW.SETFLOWDESCRIPTOR(EFD);
 139         //
 140         // //
 141         // // EXECUTE THE FLOW
 142         // //
 143         // EXECUTE(REALIZEDFLOW, TRUE);
 144         // //
 145         // }
 146         // }
 147         //
 148         // PROTECTED MAP<STRING, EXECUTIONSPECATTRIBUTE>
 149         // READEXECUTIONSPECATTRIBUTES(
 150         // NODE NODE) {
 151         // TRY {
 152         // MAP<STRING, EXECUTIONSPECATTRIBUTE> ATTRS = NEW HASHMAP<STRING,
 153         // EXECUTIONSPECATTRIBUTE>();
 154         // FOR (NODEITERATOR NIT = NODE.GETNODES(); NIT.HASNEXT();) {
 155         // NODE SPECATTRNODE = NIT.NEXTNODE();
 156         // IF (SPECATTRNODE
 157         // .ISNODETYPE(SLCTYPES.SLC_PRIMITIVE_SPEC_ATTRIBUTE)) {
 158         // STRING TYPE = SPECATTRNODE.GETPROPERTY(SLC_TYPE)
 159         // .GETSTRING();
 160         // OBJECT VALUE = NULL;
 161         // IF (SPECATTRNODE.HASPROPERTY(SLC_VALUE)) {
 162         // STRING VALUESTR = SPECATTRNODE.GETPROPERTY(SLC_VALUE)
 163         // .GETSTRING();
 164         // VALUE = PRIMITIVEUTILS.CONVERT(TYPE, VALUESTR);
 165         // }
 166         // PRIMITIVESPECATTRIBUTE SPECATTR = NEW PRIMITIVESPECATTRIBUTE(
 167         // TYPE, VALUE);
 168         // ATTRS.PUT(SPECATTRNODE.GETNAME(), SPECATTR);
 169         // } ELSE IF (SPECATTRNODE
 170         // .ISNODETYPE(SLCTYPES.SLC_REF_SPEC_ATTRIBUTE)) {
 171         // IF (!SPECATTRNODE.HASPROPERTY(SLC_VALUE)) {
 172         // CONTINUE;
 173         // }
 174         // INTEGER VALUE = (INT) SPECATTRNODE.GETPROPERTY(SLC_VALUE)
 175         // .GETLONG();
 176         // REFSPECATTRIBUTE SPECATTR = NEW REFSPECATTRIBUTE();
 177         // NODEITERATOR CHILDREN = SPECATTRNODE.GETNODES();
 178         // INT INDEX = 0;
 179         // STRING ID = NULL;
 180         // WHILE (CHILDREN.HASNEXT()) {
 181         // NODE CHILD = CHILDREN.NEXTNODE();
 182         // IF (INDEX == VALUE)
 183         // ID = CHILD.GETNAME();
 184         // INDEX++;
 185         // }
 186         // SPECATTR.SETVALUE(ID);
 187         // ATTRS.PUT(SPECATTRNODE.GETNAME(), SPECATTR);
 188         // }
 189         // // THROW NEW SLCEXCEPTION("UNSUPPORTED SPEC ATTRIBUTE "
 190         // // + SPECATTRNODE);
 191         // }
 192         // RETURN ATTRS;
 193         // } CATCH (REPOSITORYEXCEPTION E) {
 194         // THROW NEW SLCEXCEPTION("CANNOT READ SPEC ATTRIBUTES FROM " + NODE,
 195         // E);
 196         // }
 197         // }
 198
 199         protected JcrExecutionProcess getJcrExecutionProcess() {
 200                 return (JcrExecutionProcess) getProcess();
 201         }
 202 }