[jboss-user] [jBPM] New message: "Re: Problem retrieving running process instance"

[Oliver Schneider]

User development,

A new message was posted in the thread "Problem retrieving running process instance":

http://community.jboss.org/message/518922#518922

Author  : Oliver Schneider
Profile : http://community.jboss.org/people/Masipulami

Message:
--------------------------------------------------------------
With JBPM 3 it worked as shown in the example below. But this way does not work any more with JBPM 4.
What am I doing wrong?
 
package org.jbpm.tutorial.db;
 
import java.util.List;
 
import junit.framework.TestCase;
 
import org.jbpm.db.GraphSession;
import org.jbpm.db.JbpmSession;
import org.jbpm.db.JbpmSessionFactory;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;
 
public class HelloWorldDbTest extends TestCase {
 
  // We need one JbpmSessionFactory per application.  So we put it in 
  // a static variable. The JbpmSessionFactory will be used in the 
  // test methods to create JbpmSession's.
  static JbpmSessionFactory jbpmSessionFactory = 
      JbpmSessionFactory.buildJbpmSessionFactory();
  
  static {
    // Since the hypersonic in-memory database is a new, fresh database,
    // we need to create the schema at runtime before we start the tests.
    // The next line creates the database tables and foreign key 
    // constraints. 
    jbpmSessionFactory.getJbpmSchema().createSchema();
  }
 
  public void testSimplePersistence() {
    // Between the 3 method calls below, all data is passed via the 
    // database.  Here, in this unit test, these 3 methods are executed
    // right after each other because we want to test a complete process
    // scenario.  But in reality, these methods represent different 
    // requests to a server.
    
    // Since we start with a clean, empty in-memory database, we have to 
    // deploy the process first.  In reality, this is done once by the 
    // process developer.
    deployProcessDefinition();
 
    // Suppose we want to start a process instance (=process execution)
    // when a user submits a form in a web application...
    processInstanceIsCreatedWhenUserSubmitsWebappForm();
 
    // Then, the arrival of an asynchronous message will continue 
    // execution.
    theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();
  }
 
  public void deployProcessDefinition() {
    // This test shows a process definition and one execution 
    // of the process definition.  The process definition has 
    // 3 nodes: an unnamed start-state, a state 's' and an 
    // end-state named 'end'.
    ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
      "<process-definition name='hello world'>" +
      "  <start-state name='start'>" +
      "    <transition to='s' />" +
      "  </start-state>" +
      "  <state name='s'>" +
      "    <transition to='end' />" +
      "  </state>" +
      "  <end-state name='end' />" +
      "</process-definition>"
    );
    
    // Let's open a new persistence session
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session
    jbpmSession.beginTransaction();
    
    // Save the process definition in the database 
    jbpmSession
        .getGraphSession()
        .saveProcessDefinition(processDefinition);
    
    // Commit the transaction
    jbpmSession.commitTransaction();
    // And close the jbpmSession.
    jbpmSession.close();
  }
 
  public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {
    // The code in this method could be inside a struts-action 
    // or a JSF managed bean. 
    
    // Let's open a new persistence session
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session.
    jbpmSession.beginTransaction();
    
    // Now we can query the database for the process definition that we 
    // deployed above. 
    ProcessDefinition processDefinition = 
        jbpmSession
          .getGraphSession()
          .findLatestProcessDefinition("hello world");
    
    // With the processDefinition that we retrieved from the database, we 
    // can create an execution of the process definition just like in the 
    // hello world example (which was without persistence).
    ProcessInstance processInstance = 
        new ProcessInstance(processDefinition);
    
    Token token = processInstance.getRootToken(); 
    assertEquals("start", token.getNode().getName());
    // Let's start the process execution
    token.signal();
    // Now the process is in the state 's'.
    assertEquals("s", token.getNode().getName());
    
    // Now the processInstance is saved in the database.  So the 
    // current state of the execution of the process is stored in the 
    // database.  
    jbpmSession
        .getGraphSession()
        .saveProcessInstance(processInstance);
    // The method below will get the process instance back out 
    // of the database and resume execution by providing another 
    // external signal.
 
    // At the end of the webapp action, the transaction is committed.
    jbpmSession.commitTransaction();
    // And close the jbpmSession.
    jbpmSession.close();
  }
 
  public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {
    // The code in this method could be the content of a message driven bean.
    
    // Let's open a new persistence session.
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session
    // note that it's also possible to use a jdbc connection from a 
    // DataSource in your application server.
    jbpmSession.beginTransaction();
    GraphSession graphSession = jbpmSession.getGraphSession();
 
    // First, we need to get the process instance back out of the database.
    // There are several options to know what process instance we are dealing 
    // with here.  The easiest in this simple test case is just to look for 
    // the full list of process instances.  That should give us only one 
    // result.  So let's look up the process definition.
    ProcessDefinition processDefinition = 
        graphSession.findLatestProcessDefinition("hello world");
 
    // Now, we search for all process instances of this process definition.
    List processInstances = 
        graphSession.findProcessInstances(processDefinition.getId());
    
    // Because we know that in the context of this unit test, there is 
    // only one execution.  In real life, the processInstanceId can be 
    // extracted from the content of the message that arrived or from 
    // the user making a choice.
    ProcessInstance processInstance = 
        (ProcessInstance) processInstances.get(0);
    
    // Now we can continue the execution.  Note that the processInstance
    // delegates signals to the main path of execution (=the root token).
    processInstance.signal();
    
    // After this signal, we know the process execution should have 
    // arrived in the end-state.
    assertTrue(processInstance.hasEnded());
    
    // Now we can update the state of the execution in the database
    graphSession.saveProcessInstance(processInstance);
 
    // At the end of the MDB, the transaction is committed.
    jbpmSession.commitTransaction();
    // And the jbpmSession is closed.
    jbpmSession.close();
  }
}

--------------------------------------------------------------

To reply to this message visit the message page: http://community.jboss.org/message/518922#518922