use of com.salaboy.model.Person in project jBPM5-Developer-Guide by Salaboy.
the class MultiSessionsPatternsTest method multiSessionsCollaboration.
/*
* This test shows how a master session can automatically complete a work
* item handler in a slave session when the required information is present.
*/
@Test
public void multiSessionsCollaboration() throws Exception {
//Creates an entity manager and get the user transaction. We are going
//to need them later to interact with the business entities persisted
//by the work item handlers we have configured in our session.
EntityManager em = getEmf().createEntityManager();
UserTransaction ut = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
//Creates and persists a new BusinessEntity containing the information
//required by this test.
StatefulKnowledgeSession interactionSession = null;
BusinessEntity interactionSessionEntity = null;
try {
// This needs to happen in the same transaction if I want to keep it consistent
ut.begin();
//Creates a new session.
interactionSession = createProcessInteractionKnowledgeSession("InteractionSession", em);
//persists the required business entity.
interactionSessionEntity = new BusinessEntity(interactionSession.getId(), 0, 0, "InteractionSession");
// I need to join the Drools/jBPM transaction
em.joinTransaction();
em.persist(interactionSessionEntity);
ut.commit();
} catch (Exception e) {
System.out.println("Rolling Back because of: " + e.getMessage());
ut.rollback();
fail(e.getMessage());
}
assertNotNull(interactionSessionEntity);
assertNotNull(interactionSessionEntity.getId());
//Dispose the session.
interactionSession.dispose();
//Initial parameters for process instance #1
Person person = new Person("Salaboy", 29);
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
//Creates the ksession for process instance #1
StatefulKnowledgeSession ksession = createProcessOneKnowledgeSession(person.getId());
registerWorkItemHandlers(ksession, person.getId(), em);
//Starts process instance #1
ksession.startProcess("com.salaboy.process.AsyncInteractions", params);
//Disposes the session.
ksession.dispose();
// The interaction Session has the responsability of mapping the WorkItems Ids with their corresponding
// Business Interactions. This can be done with a Map/Registry or with a Knowledge Session to
// describe more complex patterns
BusinessEntity sessionInteractionKey = getBusinessEntity("InteractionSession", em);
interactionSession = loadKnowldgeSession(sessionInteractionKey.getSessionId(), "InteractionSession", em);
interactionSession.setGlobal("em", em);
interactionSession.setGlobal("ksessionSupport", this);
// Look for all the pending Business Keys which represent an interaction and insert them into the interaction session
List<BusinessEntity> pendingBusinessEntities = getActiveBusinessEntities(em);
for (BusinessEntity be : pendingBusinessEntities) {
if (!be.getBusinessKey().equals("InteractionSession")) {
interactionSession.insert(be);
}
}
// As soon as we add Data the completion will be triggered and the process will continue
interactionSession.insert(new Data());
interactionSession.fireAllRules();
ksession.dispose();
}
use of com.salaboy.model.Person in project jBPM5-Developer-Guide by Salaboy.
the class MultiSessionsPatternsTest method multiSessionsWithSessionLocator.
/**
* This test uses the concept of a SessionLocator to register slaves sessions.
* Based on rules, the master session decides which (process definition),
* when (declaratively expressed with rules) and where (in which slave session)
* to start a process instance.
*/
@Test
public void multiSessionsWithSessionLocator() throws Exception {
EntityManager em = getEmf().createEntityManager();
UserTransaction ut = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
StatefulKnowledgeSession interactionSession = null;
BusinessEntity interactionSessionEntity = null;
try {
// This needs to happen in the same transaction if I want to keep it consistent
ut.begin();
interactionSession = createProcessInteractionKnowledgeSession("InteractionSession", em);
interactionSessionEntity = new BusinessEntity(interactionSession.getId(), 0, 0, "InteractionSession");
// I need to join the Drools/jBPM transaction
em.joinTransaction();
em.persist(interactionSessionEntity);
ut.commit();
} catch (Exception e) {
System.out.println("Rolling Back because of: " + e.getMessage());
ut.rollback();
}
assertNotNull(interactionSessionEntity);
assertNotNull(interactionSessionEntity.getId());
interactionSession.dispose();
// Let's create a session which contains a process and register it in the interaction session:
StatefulKnowledgeSession processSession = createProcessOneKnowledgeSessionAndRegister("My Business Unit Session", interactionSessionEntity, em);
processSession.dispose();
Person person = new Person("Salaboy", 29);
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
interactionSession = loadKnowldgeSession(interactionSessionEntity.getSessionId(), "InteractionSession", em);
KnowledgeRuntimeLoggerFactory.newConsoleLogger(interactionSession);
interactionSession.setGlobal("em", em);
interactionSession.setGlobal("ksessionSupport", this);
// Let's insert a fact in the master session and let the rules choose the appropriate session for us to start a process
interactionSession.insert(person);
// The process will be selected and started. Because it contains an async activity a new BusinessEntity will be created
interactionSession.fireAllRules();
// Look for all the pending Business Keys which represent an interaction and insert them into the interaction session
List<BusinessEntity> pendingBusinessEntities = em.createQuery("select be from BusinessEntity be where " + " be.active = true").getResultList();
for (BusinessEntity be : pendingBusinessEntities) {
if (!be.getBusinessKey().equals("InteractionSession")) {
interactionSession.insert(be);
}
}
// As soon as we add Data the completion will be triggered and the process will continue
interactionSession.insert(new Data());
interactionSession.fireAllRules();
interactionSession.dispose();
}
use of com.salaboy.model.Person in project jBPM5-Developer-Guide by Salaboy.
the class PersistentProcessTest method processInstancePersistentAsyncTest.
@Test
public void processInstancePersistentAsyncTest() throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(new ClassPathResource("process-async-interactions.bpmn"), ResourceType.BPMN2);
if (kbuilder.hasErrors()) {
for (KnowledgeBuilderError error : kbuilder.getErrors()) {
System.out.println(">>> Error:" + error.getMessage());
}
fail(">>> Knowledge couldn't be parsed! ");
}
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
Environment env = EnvironmentFactory.newEnvironment();
EntityManagerFactory emf = Persistence.createEntityManagerFactory("org.jbpm.runtime");
env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
env.set(EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager());
// Let's create a Persistence Knowledge Session
System.out.println(" >>> Let's create a Persistent Knowledge Session");
final StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession(kbase, null, env);
int sessionId = ksession.getId();
assertNotNull(sessionId);
assertTrue(sessionId != 0);
// We need to register the WorkItems and Listeners that the session will use
MockAsyncHTWorkItemHandler mockAsyncHTWorkItemHandler = new MockAsyncHTWorkItemHandler();
MockExternalServiceWorkItemHandler mockExternalServiceWorkItemHandler = new MockExternalServiceWorkItemHandler();
ksession.getWorkItemManager().registerWorkItemHandler("Human Task", mockAsyncHTWorkItemHandler);
ksession.getWorkItemManager().registerWorkItemHandler("External Service Call", mockExternalServiceWorkItemHandler);
//KnowledgeRuntimeLoggerFactory.newConsoleLogger(ksession);
// Let's create a Process Instance
Person person = new Person("Salaboy", 29);
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
//Each Command will generate an interaction
System.out.println(" >>> Let's Create Process Instance");
ProcessInstance processInstance = ksession.createProcessInstance("com.salaboy.process.AsyncInteractions", params);
System.out.println(" >>> Let's Start the Process Instance");
ksession.startProcessInstance(processInstance.getId());
//Now we need to manually complete the Human Interaction to continue the process
System.out.println(">>> Completing the first Human Interaction");
ksession.getWorkItemManager().completeWorkItem(mockAsyncHTWorkItemHandler.getId(), null);
// It will execute the automatic external interaction and then another Human Interaction will need to be completed
System.out.println(">>> Completing the second Human Interaction");
ksession.getWorkItemManager().completeWorkItem(mockAsyncHTWorkItemHandler.getId(), null);
// We need to dispose the session, because the reference to this ksession object will no longer be valid
// because another thread could load the same session and execute a different command.
System.out.println(">>> Disposing Session");
ksession.dispose();
}
use of com.salaboy.model.Person in project jBPM5-Developer-Guide by Salaboy.
the class PersistentProcessTest method processInstancesPersistenceFaultTest.
@Test
public void processInstancesPersistenceFaultTest() throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(new ClassPathResource("process-async-interactions.bpmn"), ResourceType.BPMN2);
if (kbuilder.hasErrors()) {
for (KnowledgeBuilderError error : kbuilder.getErrors()) {
System.out.println(">>> Error:" + error.getMessage());
}
fail(">>> Knowledge couldn't be parsed! ");
}
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
Environment env = EnvironmentFactory.newEnvironment();
EntityManagerFactory emf = Persistence.createEntityManagerFactory("org.jbpm.runtime");
env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
env.set(EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager());
// Let's create a Persistence Knowledge Session
System.out.println(" >>> Let's create a Persistent Knowledge Session");
final StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession(kbase, null, env);
int sessionId = ksession.getId();
assertNotNull(sessionId);
assertTrue(sessionId != 0);
// We need to register the WorkItems and Listeners that the session will use
MockHTWorkItemHandler mockHTWorkItemHandler = new MockHTWorkItemHandler();
MockFaultWorkItemHandler mockFaultWorkItemHandler = new MockFaultWorkItemHandler();
ksession.getWorkItemManager().registerWorkItemHandler("Human Task", mockHTWorkItemHandler);
ksession.getWorkItemManager().registerWorkItemHandler("External Service Call", mockFaultWorkItemHandler);
//KnowledgeRuntimeLoggerFactory.newConsoleLogger(ksession);
// Let's create a Process Instance
Person person = new Person("Salaboy", 29);
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
//Each Command will generate an interaction
System.out.println(">>> Let's Create Process Instance");
ProcessInstance processInstance = ksession.createProcessInstance("com.salaboy.process.AsyncInteractions", params);
System.out.println(">>> Let's Start the Process Instance");
try {
ksession.startProcessInstance(processInstance.getId());
} catch (Exception e) {
assertTrue(e instanceof WorkflowRuntimeException);
System.out.println(">>> Disposing Session");
// We need to dispose the session, because the reference to this ksession object will no longer be valid
// because another thread could load the same session and execute a different command.
ksession.dispose();
// The startProcess transaction never gets commited.
EntityManager em = emf.createEntityManager();
// The ProcessInstance is in the same state as when it was created
List resultList = em.createQuery("select p from ProcessInstanceInfo p").getResultList();
assertEquals(1, resultList.size());
assertEquals(0, ((WorkflowProcessInstanceImpl) processInstance).getNodeInstances().size());
// No WorkItemInfo was commited.
resultList = em.createQuery("select w from WorkItemInfo w").getResultList();
assertEquals(0, resultList.size());
}
}
use of com.salaboy.model.Person in project jBPM5-Developer-Guide by Salaboy.
the class PersistentProcessTest method processInstancePersistentTest.
@Test
public void processInstancePersistentTest() throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(new ClassPathResource("process-async-interactions.bpmn"), ResourceType.BPMN2);
if (kbuilder.hasErrors()) {
for (KnowledgeBuilderError error : kbuilder.getErrors()) {
System.out.println(">>> Error:" + error.getMessage());
}
fail(">>> Knowledge couldn't be parsed! ");
}
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
Environment env = EnvironmentFactory.newEnvironment();
EntityManagerFactory emf = Persistence.createEntityManagerFactory("org.jbpm.runtime");
env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
env.set(EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager());
// Let's create a Persistence Knowledge Session
System.out.println(" >>> Let's create a Persistent Knowledge Session");
final StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession(kbase, null, env);
int sessionId = ksession.getId();
assertNotNull(sessionId);
assertTrue(sessionId != 0);
// We need to register the WorkItems and Listeners that the session will use
MockHTWorkItemHandler mockHTWorkItemHandler = new MockHTWorkItemHandler();
MockExternalServiceWorkItemHandler mockExternalServiceWorkItemHandler = new MockExternalServiceWorkItemHandler();
ksession.getWorkItemManager().registerWorkItemHandler("Human Task", mockHTWorkItemHandler);
ksession.getWorkItemManager().registerWorkItemHandler("External Service Call", mockExternalServiceWorkItemHandler);
//KnowledgeRuntimeLoggerFactory.newConsoleLogger(ksession);
// Let's create a Process Instance
Person person = new Person("Salaboy", 29);
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
//Each Command will generate an interaction
System.out.println(">>> Let's Create Process Instance");
ProcessInstance processInstance = ksession.createProcessInstance("com.salaboy.process.AsyncInteractions", params);
System.out.println(">>> Let's Start the Process Instance");
long processInstanceOne = processInstance.getId();
ksession.startProcessInstance(processInstanceOne);
// We need to dispose the session, because the reference to this ksession object will no longer be valid
// because another thread could load the same session and execute a different command.
System.out.println(">>> Disposing Session");
ksession.dispose();
// Let's reload the session and create a different process instance inside it
StatefulKnowledgeSession loadedKsession = JPAKnowledgeService.loadStatefulKnowledgeSession(sessionId, kbase, null, env);
// All the listeners and WorkItemHandlers are volatile, so we need to register them each time that we reload the session
// from the DB.
loadedKsession.getWorkItemManager().registerWorkItemHandler("Human Task", mockHTWorkItemHandler);
loadedKsession.getWorkItemManager().registerWorkItemHandler("External Service Call", mockExternalServiceWorkItemHandler);
//KnowledgeRuntimeLoggerFactory.newConsoleLogger(loadedKsession);
//Let's create another instance and start it.
System.out.println(">>> Let's Create Process Instance");
processInstance = loadedKsession.createProcessInstance("com.salaboy.process.AsyncInteractions", params);
System.out.println(">>> Let's Start the Process Instance");
long processInstanceTwo = processInstance.getId();
loadedKsession.startProcessInstance(processInstanceTwo);
System.out.println(">>> Disposing Session");
loadedKsession.dispose();
StatefulKnowledgeSession checkKsession = JPAKnowledgeService.loadStatefulKnowledgeSession(sessionId, kbase, null, env);
assertEquals(0, checkKsession.getProcessInstances().size());
checkKsession.dispose();
}
Aggregations