ACT-60 worked out pvm execution model further to handle more bpmn activity types

modules/activiti-engine-test-cfg/src/test/java/org/activiti/test/cfg/spring/SpringTest.java

@@ -84,7 +84,7 @@ public class SpringTest {
     List<Task> tasks = processEngine.getTaskService().findAssignedTasks("kermit");
     assertEquals(before + 1, tasks.size());
 
-    processEngine.getRuntimeService().deleteProcessInstance(processInstance.getId());
+    processEngine.getRuntimeService().endProcessInstance(processInstance.getId());
     
   }
 
@@ -95,7 +95,7 @@ public class SpringTest {
             CollectionUtil.singletonMap("input", "Activiti BPM Engine"));
     ActivityInstance activityInstance = runtimeService.findActivityInstanceByProcessInstanceIdAndActivityId(pi.getId(), "waitState");
     assertEquals("ACTIVITI BPM ENGINE", runtimeService.getVariable(activityInstance.getId(), "input"));
-    processEngine.getRuntimeService().deleteProcessInstance(activityInstance.getId());
+    processEngine.getRuntimeService().endProcessInstance(activityInstance.getId());
   }
 
   @Test

modules/activiti-engine/src/main/java/org/activiti/engine/RuntimeService.java

@@ -36,7 +36,7 @@ public interface RuntimeService {
   ProcessInstance startProcessInstanceById(String processDefinitionId, Map<String, Object> variables);
   
   /** delete an existing runtime process instance */
-  void deleteProcessInstance(String processInstanceId);
+  void endProcessInstance(String processInstanceId, String nonCompletionReason);
   
   /** gets the details of a process instance 
    * @return the process instance or null if no process instance could be found with the given id. */

modules/activiti-engine/src/main/java/org/activiti/engine/impl/RuntimeServiceImpl.java

@@ -19,7 +19,7 @@ import org.activiti.engine.ActivityInstance;
 import org.activiti.engine.ProcessInstance;
 import org.activiti.engine.ProcessInstanceQuery;
 import org.activiti.engine.RuntimeService;
-import org.activiti.engine.impl.cmd.DeleteProcessInstanceCmd;
+import org.activiti.engine.impl.cmd.EndProcessInstanceCmd;
 import org.activiti.engine.impl.cmd.FindActivitiyInstanceCmd;
 import org.activiti.engine.impl.cmd.FindActivityInstanceInActivityCmd;
 import org.activiti.engine.impl.cmd.FindProcessInstanceCmd;
@@ -38,8 +38,8 @@ public class RuntimeServiceImpl extends ServiceImpl implements RuntimeService {
     return commandExecutor.execute(new FindActivitiyInstanceCmd(activityInstanceId));
   }
 
-  public void deleteProcessInstance(String processInstanceId) {
-    commandExecutor.execute(new DeleteProcessInstanceCmd(processInstanceId));
+  public void endProcessInstance(String processInstanceId, String nonCompletionReason) {
+    commandExecutor.execute(new EndProcessInstanceCmd(processInstanceId, nonCompletionReason));
   }
 
   public ProcessInstance startProcessInstanceByKey(String processDefinitionKey) {

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/BpmnActivityBehavior.java

@@ -98,7 +98,7 @@ public class BpmnActivityBehavior {
           log.fine("No outgoing sequence flow found for " + activityContext.getActivity().getId() 
                   + ". Ending execution.");
         }
-        activityContext.end();
+        activityContext.endActivityInstance();
         
       }
   }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/NoneEndEventActivity.java

@@ -22,7 +22,7 @@ public class NoneEndEventActivity extends AbstractBpmnActivity {
   
   public void start(ActivityContext activityContext) throws Exception {
     
-    activityContext.end();
+    activityContext.endActivityInstance();
     
 //    // TODO: needs cleanup!
 //    ActivityImpl currentActivity = (ActivityImpl) activityContext.getActivity();

modules/activiti-engine/src/main/java/org/activiti/engine/impl/cfg/RuntimeSession.java

@@ -34,7 +34,7 @@ import org.activiti.engine.impl.persistence.runtime.VariableInstanceEntity;
  */
 public interface RuntimeSession {
   
-  void deleteProcessInstance(String processInstanceId);
+  void endProcessInstance(String processInstanceId, String nonCompletionReason);
   ProcessInstanceEntity findProcessInstanceById(String processInstanceId);
   List<ProcessInstanceEntity> findProcessInstancesByProcessDefintionId(String processDefinitionId);
   ProcessInstanceEntity findSubProcessInstance(String superExecutionId);

modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/DeleteProcessInstanceCmd.java → modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/EndProcessInstanceCmd.java

@@ -12,32 +12,26 @@
  */
 package org.activiti.engine.impl.cmd;
 
-import org.activiti.engine.ActivitiException;
 import org.activiti.engine.impl.interceptor.CommandContext;
-import org.activiti.engine.impl.persistence.runtime.ProcessInstanceEntity;
 
 
 /**
  * @author Joram Barrez
  */
-public class DeleteProcessInstanceCmd extends CmdVoid {
+public class EndProcessInstanceCmd extends CmdVoid {
   
   protected String processInstanceId;
-  
-  public DeleteProcessInstanceCmd(String processInstanceId) {
-    this.processInstanceId = processInstanceId; 
+  protected String nonCompletionReason;
+
+  public EndProcessInstanceCmd(String processInstanceId, String nonCompletionReason) {
+    this.processInstanceId = processInstanceId;
+    this.nonCompletionReason = nonCompletionReason;
   }
-  
+
   public void executeVoid(CommandContext commandContext) { 
-    ProcessInstanceEntity processInstance = commandContext
+    commandContext
       .getRuntimeSession()
-      .findProcessInstanceById(processInstanceId);
-    
-    if (processInstance==null) {
-      throw new ActivitiException("process instance "+processInstanceId+" does not exist");
-    }
-    
-    processInstance.delete();
+      .endProcessInstance(processInstanceId, nonCompletionReason);
   }
 
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/db/DbRepositorySession.java

@@ -96,7 +96,7 @@ public class DbRepositorySession implements Session, RepositorySession {
         for (ProcessInstance processInstance: processInstances) {
           commandContext
             .getRuntimeSession()
-            .deleteProcessInstance(processInstance.getId());
+            .endProcessInstance(processInstance.getId());
         }
       }
     }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/db/DbRuntimeSession.java

@@ -43,8 +43,8 @@ public class DbRuntimeSession implements Session, RuntimeSession {
     this.dbSqlSession = CommandContext.getCurrentSession(DbSqlSession.class);
   }
 
-  public void deleteProcessInstance(String processInstanceId) {
-    findProcessInstanceById(processInstanceId).delete();
+  public void endProcessInstance(String processInstanceId, String nonCompletionReason) {
+    findProcessInstanceById(processInstanceId).end();
   }
 
   public ProcessInstanceEntity findProcessInstanceById(String processInstanceId) {

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/runtime/ActivityInstanceEntity.java

@@ -70,19 +70,11 @@ public class ActivityInstanceEntity extends ActivityInstanceImpl implements Acti
   }
   
   @Override
-  protected ActivityInstanceEntity createActivityInstance(ActivityImpl activity) {
-    ActivityInstanceEntity activityInstance = createAndInsert(activity, this);
-    activityInstances.add(activityInstance);
-    return activityInstance;
-  }
-
-  @Override
-  public void removeActivityInstance(ActivityInstanceImpl activityInstance) {
-    super.removeActivityInstance(activityInstance);
-    ((ActivityInstanceEntity)activityInstance).delete();
+  protected ActivityInstanceEntity newActivityInstance(ActivityImpl activity) {
+    return createAndInsert(activity, this);
   }
 
-  public void delete() {
+  public void destroy() {
     CommandContext
       .getCurrent()
       .getRuntimeSession()

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/runtime/ProcessInstanceEntity.java

@@ -70,12 +70,18 @@ public class ProcessInstanceEntity extends ProcessInstanceImpl implements Proces
     super.removeActivityInstance(activityInstance);
     ((ActivityInstanceEntity)activityInstance).delete();
   }
-
+  
+  /** normal end */
   @Override
-  public void remove() {
+  public void end() {
+    end(null);
+  }
+
+  /** abnormal end of a process instance */
+  public void end(String nonCompletionReason) {
     delete();
   }
-  
+
   public void delete() {
     CommandContext
       .getCurrent()

modules/activiti-pvm/src/main/java/org/activiti/pvm/activity/ActivityContext.java

@@ -13,39 +13,40 @@
 
 package org.activiti.pvm.activity;
 
-import java.util.List;
 import java.util.Map;
 
 import org.activiti.pvm.event.EventContext;
 import org.activiti.pvm.process.PvmActivity;
+import org.activiti.pvm.process.PvmProcessDefinition;
 import org.activiti.pvm.process.PvmTransition;
-import org.activiti.pvm.runtime.PvmActivityInstance;
+import org.activiti.pvm.runtime.PvmProcessInstance;
 
 
 /**
  * @author Tom Baeyens
  */
 public interface ActivityContext extends EventContext {
+  
+  // runtime structure methods
+  DelegateActivityInstance getActivityInstance();
 
+  // execution operations
   void take(PvmTransition transition);
+  void executeActivity(PvmActivity startActivity);
+  void endActivityInstance();
+  void endProcessInstance();
+  void keepAlive();
+  PvmProcessInstance createSubProcessInstance(PvmProcessDefinition processDefinition);
 
-  void end();
-
-  List<PvmTransition> getOutgoingTransitions();
-
-  PvmTransition getOutgoingTransition(String signalName);
-
-  List<PvmTransition> getIncomingTransitions();
-
-  List<PvmActivity> getActivities();
-  
+  // user variables
   void setVariable(String variableName, Object value);
-  
   Object getVariable(String variableName);
-
   Map<String, Object> getVariables();
 
-  PvmActivity getActivity();
+  // scoped activity variables
+  Object getSystemVariable(String variableName);
+  void setSystemVariable(String variableName, Object value);
 
-  PvmActivityInstance getActivityInstance();
+  // activity and whole process definition model
+  PvmActivity getActivity();
 }

modules/activiti-pvm/src/main/java/org/activiti/pvm/activity/CompositeActivityBehavior.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.pvm.activity;
+
+
+
+/**
+ * @author Tom Baeyens
+ */
+public interface CompositeActivityBehavior extends ActivityBehavior {
+
+  void activityInstanceEnded(ActivityContext activityContext) throws Exception;
+
+}

modules/activiti-pvm/src/main/java/org/activiti/pvm/activity/DelegateActivityInstance.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.pvm.activity;
+
+import java.io.Serializable;
+import java.util.Set;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public interface DelegateActivityInstance extends Serializable {
+
+  Set<? extends DelegateActivityInstance> getActivityInstances();
+}

modules/activiti-pvm/src/main/java/org/activiti/pvm/activity/SubProcessActivityBehavior.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.pvm.activity;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public interface SubProcessActivityBehavior extends ActivityBehavior {
+
+  void subProcessEnded(ActivityContext activityContext) throws Exception;
+}

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/process/ActivityImpl.java

@@ -30,6 +30,7 @@ import org.activiti.pvm.process.PvmTransition;
  */
 public class ActivityImpl extends ScopeImpl implements PvmActivity {
 
+  private static final long serialVersionUID = 1L;
   protected List<TransitionImpl> outgoingTransitions = new ArrayList<TransitionImpl>();
   protected Map<String, TransitionImpl> namedOutgoingTransitions = new HashMap<String, TransitionImpl>();
   protected List<TransitionImpl> incomingTransitions = new ArrayList<TransitionImpl>();

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/process/ProcessDefinitionImpl.java

@@ -23,6 +23,8 @@ import org.activiti.pvm.process.PvmProcessDefinition;
  */
 public class ProcessDefinitionImpl extends ScopeImpl implements PvmProcessDefinition {
   
+  private static final long serialVersionUID = 1L;
+  
   protected ActivityImpl initial;
 
   public ProcessDefinitionImpl(String id) {
@@ -34,6 +36,8 @@ public class ProcessDefinitionImpl extends ScopeImpl implements PvmProcessDefini
     return new ProcessInstanceImpl(this);
   }
 
+  // getters and setters //////////////////////////////////////////////////////
+  
   public ActivityImpl getInitial() {
     return initial;
   }

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/process/ProcessElementImpl.java

@@ -20,6 +20,7 @@ import java.util.List;
 import java.util.Map;
 
 import org.activiti.pvm.event.EventListener;
+import org.activiti.pvm.process.PvmProcessElement;
 
 
 /** common properties for process definition, activity and transition 
@@ -27,8 +28,10 @@ import org.activiti.pvm.event.EventListener;
  * 
  * @author Tom Baeyens
  */
-public class ProcessElementImpl {
+public class ProcessElementImpl implements PvmProcessElement {
 
+  private static final long serialVersionUID = 1L;
+  
   protected String id;
   protected ProcessDefinitionImpl processDefinition;
   protected Map<String, List<EventListener>> eventListeners;

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/process/ScopeImpl.java

@@ -19,20 +19,23 @@ import java.util.List;
 import java.util.Map;
 
 import org.activiti.pvm.PvmException;
+import org.activiti.pvm.process.PvmScope;
 
 
 /**
  * @author Tom Baeyens
  */
-public class ScopeImpl extends ProcessElementImpl {
+public abstract class ScopeImpl extends ProcessElementImpl implements PvmScope {
 
+  private static final long serialVersionUID = 1L;
+  
   protected List<ActivityImpl> activities = new ArrayList<ActivityImpl>();
   protected Map<String, ActivityImpl> namedActivities = new HashMap<String, ActivityImpl>();
 
   public ScopeImpl(String id, ProcessDefinitionImpl processDefinition) {
     super(id, processDefinition);
   }
-
+  
   public ActivityImpl findActivity(String activityId) {
     ActivityImpl localActivity = namedActivities.get(activityId);
     if (localActivity!=null) {

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/process/TransitionImpl.java

@@ -23,6 +23,8 @@ import org.activiti.pvm.process.PvmTransition;
  */
 public class TransitionImpl extends ProcessElementImpl implements PvmTransition {
 
+  private static final long serialVersionUID = 1L;
+  
   protected ActivityImpl source;
   protected ActivityImpl destination;
 

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/runtime/ActivityInstanceImpl.java

@@ -13,6 +13,7 @@
 
 package org.activiti.pvm.impl.runtime;
 
+import org.activiti.pvm.activity.DelegateActivityInstance;
 import org.activiti.pvm.impl.process.ActivityImpl;
 import org.activiti.pvm.runtime.PvmActivityInstance;
 
@@ -20,8 +21,10 @@ import org.activiti.pvm.runtime.PvmActivityInstance;
 /**
  * @author Tom Baeyens
  */
-public class ActivityInstanceImpl extends ScopeInstanceImpl implements PvmActivityInstance {
+public class ActivityInstanceImpl extends ScopeInstanceImpl implements PvmActivityInstance, DelegateActivityInstance {
 
+  private static final long serialVersionUID = 1L;
+  
   protected ActivityImpl activity;
   protected ExecutionContextImpl executionContext;
   protected boolean isActive;
@@ -35,6 +38,12 @@ public class ActivityInstanceImpl extends ScopeInstanceImpl implements PvmActivi
     this.parent = parent;
   }
   
+  public void create() {
+  }
+
+  public void destroy() {
+  }
+
   public void signal(String signalName, Object signalData) {
     ExecutionContextImpl.signal(this, signalName, signalData);
   }

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/runtime/ExecutionContextImpl.java

@@ -21,6 +21,7 @@ import java.util.logging.Logger;
 import org.activiti.pvm.PvmException;
 import org.activiti.pvm.activity.ActivityBehavior;
 import org.activiti.pvm.activity.ActivityContext;
+import org.activiti.pvm.activity.CompositeActivityBehavior;
 import org.activiti.pvm.activity.SignallableActivityBehaviour;
 import org.activiti.pvm.event.Event;
 import org.activiti.pvm.event.EventContext;
@@ -29,7 +30,9 @@ import org.activiti.pvm.impl.process.ActivityImpl;
 import org.activiti.pvm.impl.process.ProcessElementImpl;
 import org.activiti.pvm.impl.process.TransitionImpl;
 import org.activiti.pvm.process.PvmActivity;
+import org.activiti.pvm.process.PvmProcessDefinition;
 import org.activiti.pvm.process.PvmTransition;
+import org.activiti.pvm.runtime.PvmProcessInstance;
 
 
 /**
@@ -49,6 +52,7 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
   private static final AtomicOperation ACTIVITY_END = new ActivityEnd();
   private static final AtomicOperation PROCESS_END = new ProcessEnd();
   
+  protected ActivityImpl activity;
   
   protected ProcessInstanceImpl processInstance;
   protected ActivityInstanceImpl activityInstance;
@@ -62,6 +66,8 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
   protected String signalName;
   protected Object signalData;
   
+  protected String endReason;
+  
   protected TransitionImpl transition;
   
   protected AtomicOperation nextAtomicOperation = null;
@@ -85,6 +91,12 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
     executionContext.perform(ACTIVITY_SIGNAL);
   }
 
+  public static void endProcessInstance(ProcessInstanceImpl processInstance, String endReason) {
+    log.fine("ending "+processInstance+" because "+endReason);
+    ExecutionContextImpl executionContext = new ExecutionContextImpl();
+    executionContext.scopeInstance = processInstance;
+  }
+
   public void take(PvmTransition transition) {
     if (transition==null) {
       throw new PvmException("transition is null");
@@ -94,10 +106,15 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
     fireEvent(activityInstance.activity, Event.ACTIVITY_END, TRANSITION_ACTIVITY_END);
   }
 
-  public void end() {
+  public void endActivityInstance() {
     log.fine("ending "+activityInstance);
     fireEvent(activityInstance.activity, Event.ACTIVITY_END, ACTIVITY_END);
   }
+  
+  public void endProcessInstance() {
+    log.fine("ending "+processInstance);
+    fireEvent(processInstance.getProcessDefinition(), Event.PROCESS_END, PROCESS_END);
+  }
 
   public void executeTimerNestedActivity(ActivityImpl borderEventActivity) {
     throw new UnsupportedOperationException("please implement me");
@@ -245,18 +262,33 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
 
   protected static class ActivityEnd implements AtomicOperation {
     public void perform(ExecutionContextImpl executionContext) {
-      executionContext.activityInstance.setEnded(true);
-      ScopeInstanceImpl parent = executionContext.activityInstance.getParent();
-      parent.removeActivityInstance(executionContext.activityInstance);
+      ActivityInstanceImpl activityInstance = executionContext.activityInstance;
+      activityInstance.setEnded(true);
+      ScopeInstanceImpl parent = activityInstance.getParent();
+      activityInstance.destroy();
+      parent.removeActivityInstance(activityInstance);
       executionContext.scopeInstance = parent;
-      
-      if (parent.getActivityInstances().isEmpty()) {
-        if (parent instanceof ProcessInstanceImpl) {
+
+      if (parent instanceof ProcessInstanceImpl) {
+        if (parent.getActivityInstances().isEmpty()) {
           executionContext.activityInstance = null;
           executionContext.fireEvent(parent.getScope(), Event.PROCESS_END, PROCESS_END);
-        } else {
-          executionContext.activityInstance = (ActivityInstanceImpl) parent;
-          executionContext.end();
+        }
+      } else {
+        executionContext.activityInstance = (ActivityInstanceImpl) parent;
+        ActivityImpl activity = activityInstance.getActivity();
+        ActivityBehavior activityBehavior = activity.getActivityBehavior();
+        if (activityBehavior instanceof CompositeActivityBehavior) {
+          try {
+            ((CompositeActivityBehavior)activityBehavior).activityInstanceEnded(executionContext);
+          } catch (RuntimeException e) {
+            log.log(Level.SEVERE, getDelegationExceptionMessage(activity, "activityInstanceEnded", e), e);
+            throw e;
+          } catch (Exception e) {
+            String delegationExceptionMessage = getDelegationExceptionMessage(activity, "activityInstanceEnded", e);
+            log.log(Level.SEVERE, delegationExceptionMessage, e);
+            throw new PvmException(delegationExceptionMessage, e);
+          } 
         }
       }
     }
@@ -265,12 +297,21 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
   protected static class ProcessEnd implements AtomicOperation {
     public void perform(ExecutionContextImpl executionContext) {
       ProcessInstanceImpl processInstance = (ProcessInstanceImpl) executionContext.scopeInstance;
+      for (ActivityInstanceImpl activityInstance: processInstance.getActivityInstances()) {
+        destroyActivityInstance(activityInstance);
+      }
       processInstance.setEnded(true);
-      processInstance.remove();
+      processInstance.destroy();
+    }
+    private void destroyActivityInstance(ActivityInstanceImpl activityInstance) {
+      for (ActivityInstanceImpl nestedActivityInstance: activityInstance.getActivityInstances()) {
+        destroyActivityInstance(nestedActivityInstance);
+      }
+      activityInstance.destroy();
     }
   }
 
-  // event context methods ////////////////////////////////////////////////////
+  // user variables ///////////////////////////////////////////////////////////
   
   public void setVariable(String variableName, Object value) {
     scopeInstance.setVariable(variableName, value);
@@ -284,6 +325,16 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
     return scopeInstance.getVariables();
   }
   
+  // system variables /////////////////////////////////////////////////////////
+  
+  public void setSystemVariable(String variableName, Object value) {
+    scopeInstance.setSystemVariable(activity, variableName, value);
+  }
+  public Object getSystemVariable(String variableName) {
+    return scopeInstance.getSystemVariable(activity, variableName);
+  }
+
+  
   // activity context methods /////////////////////////////////////////////////
   
   public PvmActivity getActivity() {
@@ -320,4 +371,15 @@ public class ExecutionContextImpl implements EventContext, ActivityContext {
   public List<PvmActivity> getActivities() {
     return (List) activityInstance.getActivity().getActivities();
   }
+
+  public PvmProcessInstance createSubProcessInstance(PvmProcessDefinition processDefinition) {
+    return null;
+  }
+
+  public void executeActivity(PvmActivity startActivity) {
+  }
+
+  public void keepAlive() {
+  }
+
 }

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/runtime/ProcessInstanceImpl.java

@@ -25,6 +25,8 @@ import org.activiti.pvm.runtime.PvmProcessInstance;
  */
 public class ProcessInstanceImpl extends ScopeInstanceImpl implements PvmProcessInstance {
   
+  private static final long serialVersionUID = 1L;
+
   protected ProcessInstanceImpl() {
   }
   
@@ -36,7 +38,7 @@ public class ProcessInstanceImpl extends ScopeInstanceImpl implements PvmProcess
     ExecutionContextImpl.startProcessInstance(this);
   }
   
-  public void remove() {
+  public void destroy() {
   }
 
   public List<String> findActivityIds() {

modules/activiti-pvm/src/main/java/org/activiti/pvm/impl/runtime/ScopeInstanceImpl.java

@@ -32,11 +32,14 @@ import org.activiti.pvm.runtime.PvmScopeInstance;
  */
 public class ScopeInstanceImpl implements PvmScopeInstance {
 
+  private static final long serialVersionUID = 1L;
+  
   protected ProcessDefinitionImpl processDefinition;
   protected ScopeImpl scope;
   protected ScopeInstanceImpl parent;
   protected Set<ActivityInstanceImpl> activityInstances = new HashSet<ActivityInstanceImpl>();
   protected Map<String, Object> variables;
+  protected Map<String, Object> systemVariables;
   protected boolean isEnded;
   
   protected ScopeInstanceImpl() {    
@@ -48,12 +51,17 @@ public class ScopeInstanceImpl implements PvmScopeInstance {
   }
 
   protected ActivityInstanceImpl createActivityInstance(ActivityImpl activity) {
-    ActivityInstanceImpl activityInstance = new ActivityInstanceImpl(activity, this);
+    ActivityInstanceImpl activityInstance = newActivityInstance(activity);
     activityInstances.add(activityInstance);
     return activityInstance;
   }
 
+  protected ActivityInstanceImpl newActivityInstance(ActivityImpl activity) {
+    return new ActivityInstanceImpl(activity, this);
+  }
+
   public void removeActivityInstance(ActivityInstanceImpl activityInstance) {
+    activityInstance.destroy();
     activityInstances.remove(activityInstance);
     activityInstance.setParent(null);
   }
@@ -91,7 +99,7 @@ public class ScopeInstanceImpl implements PvmScopeInstance {
   }
 
   
-  // variables ////////////////////////////////////////////////////////////////
+  // user variables ///////////////////////////////////////////////////////////
   
   public boolean hasVariable(String variableName) {
     if (getVariables().containsKey(variableName)) {
@@ -157,6 +165,28 @@ public class ScopeInstanceImpl implements PvmScopeInstance {
     }
   }
   
+  // system variables /////////////////////////////////////////////////////////
+  
+  public void setSystemVariable(ActivityImpl activity, String variableName, Object value) {
+    if (systemVariables==null) {
+      systemVariables = new HashMap<String, Object>();
+    }
+    String systemVariableKey = getSystemVariableKey(activity, variableName);
+    systemVariables.put(systemVariableKey, value);
+  }
+  
+  public Object getSystemVariable(ActivityImpl activity, String variableName) {
+    if (systemVariables==null) {
+      return null;
+    }
+    String systemVariableKey = getSystemVariableKey(activity, variableName);
+    return systemVariables.get(systemVariableKey);
+  }
+
+  protected String getSystemVariableKey(ActivityImpl activity, String variableName) {
+    return "["+activity.getId()+"|"+variableName+"]";
+  }
+
   // end //////////////////////////////////////////////////////////////////////
   
   public void end() {

modules/activiti-pvm/src/main/java/org/activiti/pvm/process/PvmActivity.java

@@ -13,14 +13,17 @@
 
 package org.activiti.pvm.process;
 
+import java.util.List;
+
 
 /**
  * @author Tom Baeyens
  */
-public interface PvmActivity {
+public interface PvmActivity extends PvmScope {
+
+  PvmScope getParent();
 
-  public String getId();
-  
-  Object getProperty(String name);
+  List<? extends PvmTransition> getIncomingTransitions();
 
+  List<? extends PvmTransition> getOutgoingTransitions();
 }

modules/activiti-pvm/src/main/java/org/activiti/pvm/process/PvmProcessDefinition.java

@@ -19,10 +19,10 @@ import org.activiti.pvm.runtime.PvmProcessInstance;
 /**
  * @author Tom Baeyens
  */
-public interface PvmProcessDefinition {
+public interface PvmProcessDefinition extends PvmScope {
 
   PvmProcessInstance createProcessInstance();
 
-  Object getProperty(String name);
+  PvmActivity getInitial();
 
 }

modules/activiti-pvm/src/main/java/org/activiti/pvm/process/PvmProcessElement.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.pvm.process;
+
+import java.io.Serializable;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public interface PvmProcessElement extends Serializable {
+
+  String getId();
+  
+  PvmProcessDefinition getProcessDefinition();
+  
+  Object getProperty(String name);
+
+}

modules/activiti-pvm/src/main/java/org/activiti/pvm/process/PvmScope.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.pvm.process;
+
+import java.util.List;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public interface PvmScope extends PvmProcessElement {
+
+  List<? extends PvmActivity> getActivities();
+  
+  PvmActivity findActivity(String activityId);
+
+}

modules/activiti-pvm/src/main/java/org/activiti/pvm/process/PvmTransition.java

@@ -14,12 +14,13 @@
 package org.activiti.pvm.process;
 
 
+
 /**
  * @author Tom Baeyens
  */
-public interface PvmTransition {
+public interface PvmTransition extends PvmProcessElement {
+
+  PvmActivity getSource();
 
-  public String getId();
-  
-  Object getProperty(String name);
+  PvmActivity getDestination();
 }

modules/activiti-pvm/src/main/java/org/activiti/pvm/runtime/PvmScopeInstance.java

@@ -13,13 +13,14 @@
 
 package org.activiti.pvm.runtime;
 
+import java.io.Serializable;
 import java.util.Map;
 
 
 /**
  * @author Tom Baeyens
  */
-public interface PvmScopeInstance {
+public interface PvmScopeInstance extends Serializable {
 
   boolean hasVariable(String variableName);
 

modules/activiti-pvm/src/test/java/org/activiti/pvm/test/PvmConcurrencyTest.java

@@ -20,6 +20,7 @@ import org.activiti.pvm.process.PvmProcessDefinition;
 import org.activiti.pvm.runtime.PvmActivityInstance;
 import org.activiti.pvm.runtime.PvmProcessInstance;
 import org.activiti.test.pvm.activities.Automatic;
+import org.activiti.test.pvm.activities.End;
 import org.activiti.test.pvm.activities.ParallelGateway;
 import org.activiti.test.pvm.activities.WaitState;
 import org.junit.Test;
@@ -56,14 +57,14 @@ public class PvmConcurrencyTest extends PvmTestCase {
         .transition("end")
       .endActivity()
       .createActivity("end")
-        .behavior(new WaitState())
+        .behavior(new End())
       .endActivity()
     .buildProcessDefinition();
     
     PvmProcessInstance processInstance = processDefinition.createProcessInstance(); 
     processInstance.start();
     
-    assertNotNull(processInstance.findActivityInstance("end"));
+    assertTrue(processInstance.isEnded());
   }
 
   @Test

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/Automatic.java

@@ -24,7 +24,7 @@ import org.activiti.pvm.process.PvmTransition;
 public class Automatic implements ActivityBehavior {
 
   public void start(ActivityContext activityExecutionContext) {
-    PvmTransition transition = activityExecutionContext.getOutgoingTransitions().get(0);
+    PvmTransition transition = activityExecutionContext.getActivity().getOutgoingTransitions().get(0);
     activityExecutionContext.take(transition);
   }
 

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/EmbeddedSubProcess.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.test.pvm.activities;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.activiti.pvm.activity.ActivityContext;
+import org.activiti.pvm.activity.CompositeActivityBehavior;
+import org.activiti.pvm.activity.SignallableActivityBehaviour;
+import org.activiti.pvm.process.PvmActivity;
+import org.activiti.pvm.process.PvmTransition;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public class EmbeddedSubProcess implements CompositeActivityBehavior, SignallableActivityBehaviour {
+
+  public void start(ActivityContext activityContext) throws Exception {
+    List<PvmActivity> startActivities = new ArrayList<PvmActivity>();
+    for (PvmActivity activity: activityContext.getActivity().getActivities()) {
+      if (activity.getIncomingTransitions().isEmpty()) {
+        startActivities.add(activity);
+      }
+    }
+    
+    for (PvmActivity startActivity: startActivities) {
+      activityContext.executeActivity(startActivity);
+    }
+  }
+
+  public void activityInstanceEnded(ActivityContext activityContext) throws Exception {
+    if (activityContext.getActivityInstance().getActivityInstances().isEmpty()) {
+      for (PvmTransition transition: activityContext.getActivity().getOutgoingTransitions()) {
+        activityContext.take(transition);
+      }
+    }
+  }
+
+  // used by timers
+  public void signal(ActivityContext activityContext, String signalName, Object signalData) throws Exception {
+    PvmActivity timerActivity = activityContext.getActivity().findActivity(signalName);
+    boolean isInterrupting = (Boolean) timerActivity.getProperty("isInterrupting");
+    if (!isInterrupting) {
+      activityContext.keepAlive();
+    }
+    for (PvmTransition transition: timerActivity.getOutgoingTransitions()) {
+      activityContext.take(transition);
+    }
+  }
+}

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/End.java

@@ -23,7 +23,7 @@ import org.activiti.pvm.activity.ActivityContext;
 public class End implements ActivityBehavior {
 
   public void start(ActivityContext activityContext) throws Exception {
-    activityContext.end();
+    activityContext.endActivityInstance();
   }
 
 }

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/ParallelGateway.java

@@ -12,39 +12,37 @@
  */
 package org.activiti.test.pvm.activities;
 
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
 import org.activiti.pvm.activity.ActivityBehavior;
 import org.activiti.pvm.activity.ActivityContext;
+import org.activiti.pvm.process.PvmTransition;
 
 /**
  * @author Tom Baeyens
  */
 public class ParallelGateway implements ActivityBehavior {
   
-  private static Logger log = Logger.getLogger(ParallelGateway.class.getName());
+  public void start(ActivityContext activityContext) {
+    int incomingTransitionsSize = activityContext.getActivity().getIncomingTransitions().size();
+    if (incomingTransitionsSize==1) {
+      activate(activityContext);
+      
+    } else { //incomingTransitionsSize > 1
+      
+      Integer joinCount = (Integer) activityContext.getSystemVariable("joinCount");
+      if (joinCount==null) {
+        activityContext.setSystemVariable("joinCount", new Integer(1));
+      } else {
+        joinCount = joinCount + 1;
+        if (joinCount==incomingTransitionsSize) {
+          activate(activityContext);
+        }
+      }
+    }
+  }
 
-  public void start(ActivityContext activityExecutionContext) {
-//    Activity activity = execution.getActivity();
-//
-//    List<Transition> outgoingTransitions = execution.getOutgoingTransitions();
-//    
-//    ConcurrencyController concurrencyController = new ConcurrencyController(execution);
-//    concurrencyController.inactivate();
-//    
-//    List<ActivityExecution> joinedExecutions = concurrencyController.findInactiveConcurrentExecutions(activity);
-//    
-//    int nbrOfExecutionsToJoin = execution.getIncomingTransitions().size();
-//    int nbrOfExecutionsJoined = joinedExecutions.size();
-//    
-//    if (nbrOfExecutionsJoined==nbrOfExecutionsToJoin) {
-//      log.fine("parallel gateway '"+activity.getId()+"' activates: "+nbrOfExecutionsJoined+" of "+nbrOfExecutionsToJoin+" joined");
-//      concurrencyController.takeAll(outgoingTransitions, joinedExecutions);
-//      
-//    } else if (log.isLoggable(Level.FINE)){
-//      log.fine("parallel gateway '"+activity.getId()+"' does not activate: "+nbrOfExecutionsJoined+" of "+nbrOfExecutionsToJoin+" joined");
-//    }
+  protected void activate(ActivityContext activityContext) {
+    for (PvmTransition transition: activityContext.getActivity().getOutgoingTransitions()) {
+      activityContext.take(transition);
+    }
   }
 }

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/ReusableSubProcess.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.activiti.test.pvm.activities;
+
+import org.activiti.pvm.activity.ActivityContext;
+import org.activiti.pvm.activity.SubProcessActivityBehavior;
+import org.activiti.pvm.process.PvmProcessDefinition;
+import org.activiti.pvm.process.PvmTransition;
+import org.activiti.pvm.runtime.PvmProcessInstance;
+
+
+/**
+ * @author Tom Baeyens
+ */
+public class ReusableSubProcess implements SubProcessActivityBehavior {
+
+  public void start(ActivityContext activityContext) throws Exception {
+    PvmProcessDefinition processDefinition = null;
+    PvmProcessInstance subProcessInstance = activityContext.createSubProcessInstance(processDefinition);
+    
+    // inject information from the super process into the subprocess
+//    for (variableDeclarations) {
+//      subProcessInstance.setVariable(null, null);
+//    }
+    
+    subProcessInstance.start();
+  }
+
+  public void subProcessEnded(ActivityContext activityContext) throws Exception {
+    // extract information from the subprocess and inject it into the superprocess
+//    for (variableDeclarations) {
+//      subProcessInstance.setVariable(null, null);
+//    }
+    
+    // take default transition
+    PvmTransition transition = activityContext.getActivity().getOutgoingTransitions().get(0);
+    activityContext.take(transition);
+  }
+}

modules/activiti-pvm/src/test/java/org/activiti/test/pvm/activities/WaitState.java

@@ -27,7 +27,7 @@ public class WaitState implements SignallableActivityBehaviour {
   }
   
   public void signal(ActivityContext activityExecutionContext, String signal, Object signalData) {
-    PvmTransition transition = activityExecutionContext.getOutgoingTransitions().get(0);
+    PvmTransition transition = activityExecutionContext.getActivity().getOutgoingTransitions().get(0);
     activityExecutionContext.take(transition);
   }
 }