[jbpm-commits] JBoss JBPM SVN: r3535 - in jbpm3/trunk/modules/core/src: main/java/org/jbpm/persistence and 6 other directories.

Author: alex.guizar(a)jboss.com Date: 2008-12-23 08:31:21 -0500 (Tue, 23 Dec 2008) New Revision: 3535 Added: jbpm3/trunk/modules/core/src/test/java/org/jbpm/jbpm1775/ jbpm3/trunk/modules/core/src/test/java/org/jbpm/jbpm1775/JBPM1775Test.java Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/PersistenceService.java jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/db/DbPersistenceService.java jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/jta/JtaDbPersistenceService.java jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/ProcessDefinition.hbm.xml jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/Transition.hbm.xml jbpm3/trunk/modules/core/src/main/resources/org/jbpm/taskmgmt/def/Task.hbm.xml Log: [JBPM-1775] check whether the transaction is still active before scanning the exception handlers, so that exception handlers can be loaded lazily. Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java =================================================================== --- jbpm3/trunk/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2008-12-23 13:31:21 UTC (rev 3535) @@ -40,13 +40,14 @@ import org.jbpm.instantiation.UserCodeInterceptorConfig; import org.jbpm.job.ExecuteActionJob; import org.jbpm.msg.MessageService; +import org.jbpm.persistence.db.DbPersistenceService; import org.jbpm.signal.EventService; import org.jbpm.svc.Service; import org.jbpm.svc.Services; import org.jbpm.util.EqualsUtil; -public abstract class GraphElement implements Identifiable, Serializable -{ +public abstract class GraphElement implements Identifiable, Serializable { + private static final long serialVersionUID = 1L; long id = 0; @@ -56,12 +57,10 @@ protected Map events = null; protected List exceptionHandlers = null; - public GraphElement() - { + public GraphElement() { } - public GraphElement(String name) - { + public GraphElement(String name) { setName(name); } @@ -77,61 +76,56 @@ /** * gets the events, keyd by eventType (java.lang.String). */ - public Map getEvents() - { + public Map getEvents() { return events; } - public boolean hasEvents() - { + public boolean hasEvents() { return ((events != null) && (events.size() > 0)); } - public Event getEvent(String eventType) - { + public Event getEvent(String eventType) { Event event = null; - if (events != null) - { - event = (Event)events.get(eventType); + if (events != null) { + event = (Event) events.get(eventType); } return event; } - public boolean hasEvent(String eventType) - { + public boolean hasEvent(String eventType) { boolean hasEvent = false; - if (events != null) - { + if (events != null) { hasEvent = events.containsKey(eventType); } return hasEvent; } - public Event addEvent(Event event) - { - if (event == null) - throw new IllegalArgumentException("can't add a null event to a graph element"); - if (event.getEventType() == null) - throw new IllegalArgumentException("can't add an event without an eventType to a graph element"); - if (events == null) + public Event addEvent(Event event) { + if (event == null) { + throw new IllegalArgumentException("can't add null event to graph element"); + } + if (event.getEventType() == null) { + throw new IllegalArgumentException("can't add an event without type to graph element"); + } + if (events == null) { events = new HashMap(); + } events.put(event.getEventType(), event); event.graphElement = this; return event; } - public Event removeEvent(Event event) - { + public Event removeEvent(Event event) { Event removedEvent = null; - if (event == null) - throw new IllegalArgumentException("can't remove a null event from a graph element"); - if (event.getEventType() == null) - throw new IllegalArgumentException("can't remove an event without an eventType from a graph element"); - if (events != null) - { - removedEvent = (Event)events.remove(event.getEventType()); - if (removedEvent != null) - { + if (event == null) { + throw new IllegalArgumentException("can't remove null event from graph element"); + } + if (event.getEventType() == null) { + throw new IllegalArgumentException("can't remove an event without type from graph element"); + } + if (events != null) { + removedEvent = (Event) events.remove(event.getEventType()); + if (removedEvent != null) { event.graphElement = null; } } @@ -143,90 +137,76 @@ /** * is the list of exception handlers associated to this graph element. */ - public List getExceptionHandlers() - { + public List getExceptionHandlers() { return exceptionHandlers; } - public ExceptionHandler addExceptionHandler(ExceptionHandler exceptionHandler) - { - if (exceptionHandler == null) - throw new IllegalArgumentException("can't add a null exceptionHandler to a graph element"); - if (exceptionHandlers == null) + public ExceptionHandler addExceptionHandler(ExceptionHandler exceptionHandler) { + if (exceptionHandler == null) { + throw new IllegalArgumentException("can't add null exceptionHandler to graph element"); + } + if (exceptionHandlers == null) { exceptionHandlers = new ArrayList(); + } exceptionHandlers.add(exceptionHandler); exceptionHandler.graphElement = this; return exceptionHandler; } - public void removeExceptionHandler(ExceptionHandler exceptionHandler) - { - if (exceptionHandler == null) - throw new IllegalArgumentException("can't remove a null exceptionHandler from an graph element"); - if (exceptionHandlers != null) - { - if (exceptionHandlers.remove(exceptionHandler)) - { - exceptionHandler.graphElement = null; - } + public void removeExceptionHandler(ExceptionHandler exceptionHandler) { + if (exceptionHandler == null) { + throw new IllegalArgumentException("can't remove null exceptionHandler from graph element"); } + if (exceptionHandlers != null && exceptionHandlers.remove(exceptionHandler)) { + exceptionHandler.graphElement = null; + } } - public void reorderExceptionHandler(int oldIndex, int newIndex) - { - if ((exceptionHandlers != null) && (Math.min(oldIndex, newIndex) >= 0) && (Math.max(oldIndex, newIndex) < exceptionHandlers.size())) - { + public void reorderExceptionHandler(int oldIndex, int newIndex) { + if ((exceptionHandlers != null) + && (Math.min(oldIndex, newIndex) >= 0) + && (Math.max(oldIndex, newIndex) < exceptionHandlers.size())) { Object o = exceptionHandlers.remove(oldIndex); exceptionHandlers.add(newIndex, o); + } else { + throw new IndexOutOfBoundsException("couldn't reorder element from index '" + oldIndex + + "' to index '" + newIndex + "' in " + exceptionHandlers); } - else - { - throw new IndexOutOfBoundsException("couldn't reorder element from index '" + oldIndex + "' to index '" + newIndex + "' in exceptionHandler-list '" - + exceptionHandlers + "'"); - } } // event handling /////////////////////////////////////////////////////////// - public void fireEvent(String eventType, ExecutionContext executionContext) - { + public void fireEvent(String eventType, ExecutionContext executionContext) { log.debug("event '" + eventType + "' on '" + this + "' for '" + executionContext.getToken() + "'"); - try - { + try { executionContext.setEventSource(this); - - // TODO: Is is a valid condition that the jbpmContext is not there? + + // TODO: Is it a valid condition that the jbpmContext is not there? JbpmContext jbpmContext = executionContext.getJbpmContext(); - if (jbpmContext != null) - { + if (jbpmContext != null) { Services services = jbpmContext.getServices(); - if (services != null) - { - EventService evService = (EventService)services.getService(EventService.SERVICE_NAME); - if (evService != null) - { + if (services != null) { + EventService evService = (EventService) services.getService(EventService.SERVICE_NAME); + if (evService != null) { evService.fireEvent(eventType, this, executionContext); } } } - + fireAndPropagateEvent(eventType, executionContext); - } - finally - { + } finally { executionContext.setEventSource(null); } } - public void fireAndPropagateEvent(String eventType, ExecutionContext executionContext) - { - // calculate if the event was fired on this element or if it was a propagated event + public void fireAndPropagateEvent(String eventType, ExecutionContext executionContext) { + // calculate if the event was fired on this element or if it was a + // propagated event boolean isPropagated = !(this.equals(executionContext.getEventSource())); // execute static actions Event event = getEvent(eventType); - if (event != null) - { + if (event != null) { // update the context executionContext.setEvent(event); // execute the static actions specified in the process definition @@ -242,30 +222,22 @@ // propagate the event to the parent element GraphElement parent = getParent(); - if (parent != null) - { + if (parent != null) { parent.fireAndPropagateEvent(eventType, executionContext); } } - void executeActions(List actions, ExecutionContext executionContext, boolean isPropagated) - { - if (actions != null) - { + void executeActions(List actions, ExecutionContext executionContext, boolean isPropagated) { + if (actions != null) { Iterator iter = actions.iterator(); - while (iter.hasNext()) - { - Action action = (Action)iter.next(); - if (action.acceptsPropagatedEvents() || (!isPropagated)) - { - if (action.isAsync()) - { + while (iter.hasNext()) { + Action action = (Action) iter.next(); + if (action.acceptsPropagatedEvents() || (!isPropagated)) { + if (action.isAsync()) { ExecuteActionJob job = createAsyncActionExecutionJob(executionContext.getToken(), action); - MessageService messageService = (MessageService)Services.getCurrentService(Services.SERVICENAME_MESSAGE); + MessageService messageService = (MessageService) Services.getCurrentService(Services.SERVICENAME_MESSAGE); messageService.send(job); - } - else - { + } else { executeAction(action, executionContext); } } @@ -273,8 +245,7 @@ } } - protected ExecuteActionJob createAsyncActionExecutionJob(Token token, Action action) - { + protected ExecuteActionJob createAsyncActionExecutionJob(Token token, Action action) { ExecuteActionJob job = new ExecuteActionJob(token); job.setAction(action); job.setDueDate(new Date()); @@ -282,8 +253,7 @@ return job; } - public void executeAction(Action action, ExecutionContext executionContext) - { + public void executeAction(Action action, ExecutionContext executionContext) { Token token = executionContext.getToken(); // create action log @@ -296,89 +266,55 @@ // is already locked, the token doesn't need to be locked. boolean actionMustBeLocked = (executionContext.getEvent() != null) && (!token.isLocked()); - try - { + try { // update the execution context executionContext.setAction(action); // execute the action log.debug("executing action '" + action + "'"); String lockOwnerId = "token[" + token.getId() + "]"; - try - { - if (actionMustBeLocked) - { + try { + if (actionMustBeLocked) { token.lock(lockOwnerId); } - if (UserCodeInterceptorConfig.userCodeInterceptor != null) - { + if (UserCodeInterceptorConfig.userCodeInterceptor != null) { UserCodeInterceptorConfig.userCodeInterceptor.executeAction(action, executionContext); - } - else - { + } else { action.execute(executionContext); } - } - finally - { - if (actionMustBeLocked) - { + } finally { + if (actionMustBeLocked) { token.unlock(lockOwnerId); } } - } - catch (Exception exception) - { - // NOTE that Error's are not caught because that might halt the JVM and mask the original Error. + } catch (Exception exception) { + // NOTE that Errors are not caught because that might halt the JVM and mask the original Error log.error("action threw exception: " + exception.getMessage(), exception); // log the action exception actionLog.setException(exception); - // If an exception is already set we are in an action of an exception handler - // in this case don't give the exception to the handlers but throw it to the client - // see https://jira.jboss.org/jira/browse/JBPM-1887 - if (executionContext.getException() == null) - { - // if an exception handler is available - raiseException(exception, executionContext); - } - else - { - // if there is no parent we need to throw an action exception to the client - if (exception instanceof JbpmException) - { - throw (JbpmException)exception; - } - else - { - throw new DelegationException(exception, executionContext); - } - } - } - finally - { + // if an exception handler is available + raiseException(exception, executionContext); + } finally { executionContext.setAction(null); token.endCompositeLog(); } } - List getRuntimeActionsForEvent(ExecutionContext executionContext, String eventType) - { + List getRuntimeActionsForEvent(ExecutionContext executionContext, String eventType) { List runtimeActionsForEvent = null; List runtimeActions = executionContext.getProcessInstance().getRuntimeActions(); - if (runtimeActions != null) - { + if (runtimeActions != null) { Iterator iter = runtimeActions.iterator(); - while (iter.hasNext()) - { - RuntimeAction runtimeAction = (RuntimeAction)iter.next(); + while (iter.hasNext()) { + RuntimeAction runtimeAction = (RuntimeAction) iter.next(); // if the runtime-action action is registered on this element and this eventType - if ((this.equals(runtimeAction.getGraphElement())) && (eventType.equals(runtimeAction.getEventType()))) - { + if ((this.equals(runtimeAction.getGraphElement())) + && (eventType.equals(runtimeAction.getEventType()))) { // ... add its action to the list of runtime actions if (runtimeActionsForEvent == null) runtimeActionsForEvent = new ArrayList(); @@ -418,67 +354,82 @@ * exception handler does not throw an exception, the exception is considered handled. Otherwise the search for an * applicable exception handler continues where it left of with the newly thrown exception. */ - public void raiseException(Throwable exception, ExecutionContext executionContext) throws DelegationException - { - boolean isHandled = false; - if (exceptionHandlers != null) - { - try - { - ExceptionHandler exceptionHandler = findExceptionHandler(exception); - if (exceptionHandler != null) - { - executionContext.setException(exception); - exceptionHandler.handleException(this, executionContext); - isHandled = true; + public void raiseException(Throwable exception, ExecutionContext executionContext) + throws DelegationException { + if (isAbleToHandleExceptions(executionContext)) { + if (exceptionHandlers != null) { + try { + ExceptionHandler exceptionHandler = findExceptionHandler(exception); + if (exceptionHandler != null) { + executionContext.setException(exception); + exceptionHandler.handleException(this, executionContext); + return; + } + } catch (Exception e) { + // NOTE that Error's are not caught because that might halt the JVM + // and mask the original Error. + exception = e; } } - catch (Exception e) - { - // NOTE that Error's are not caught because that might halt the JVM and mask the original Error. - exception = e; - } - } - if (!isHandled) - { GraphElement parent = getParent(); // if this graph element has a parent - if ((parent != null) && (parent != this)) - { - // action to the parent + if ((parent != null) && (!equals(parent))) { + // raise to the parent parent.raiseException(exception, executionContext); + return; } - else - { - // rollback the actions - // rollbackActions(executionContext); + } - // if there is no parent we need to throw an action exception to the client - if (exception instanceof JbpmException) - { - throw (JbpmException)exception; + // rollback the actions + // rollbackActions(executionContext); + + // if there is no parent we need to throw a delegation exception to the client + throw exception instanceof JbpmException ? (JbpmException) exception : new DelegationException( + exception, executionContext); + } + + /** + * Tells whether the given context is valid for exception handling by checking for: + * <ul> + * <li>the absence of a previous exception</li> + * <li>an active transaction, or no transaction at all</li> + * </ul> + */ + private static boolean isAbleToHandleExceptions(ExecutionContext executionContext) { + /* if an exception is already set, we are already handling an exception; + * in this case don't give the exception to the handlers but throw it to the client + * see https://jira.jboss.org/jira/browse/JBPM-1887 */ + if (executionContext.getException() != null) + return false; + + /* check whether the transaction is still active before scanning the exception handlers. + * that way we can load the exception handlers lazily + * see https://jira.jboss.org/jira/browse/JBPM-1775 */ + JbpmContext jbpmContext = executionContext.getJbpmContext(); + if (jbpmContext != null) { + Services services = jbpmContext.getServices(); + if (services != null) { + Service service = services.getPersistenceService(); + if (service instanceof DbPersistenceService) { + DbPersistenceService persistenceService = (DbPersistenceService) service; + return persistenceService.isTransactionActive() || persistenceService.getTransaction() == null; } - else - { - throw new DelegationException(exception, executionContext); - } } } + + // no transaction detected, probably running in memory only + return true; } - protected ExceptionHandler findExceptionHandler(Throwable exception) - { + protected ExceptionHandler findExceptionHandler(Throwable exception) { ExceptionHandler exceptionHandler = null; - if (exceptionHandlers != null) - { + if (exceptionHandlers != null) { Iterator iter = exceptionHandlers.iterator(); - while (iter.hasNext() && (exceptionHandler == null)) - { - ExceptionHandler candidate = (ExceptionHandler)iter.next(); - if (candidate.matches(exception)) - { + while (iter.hasNext() && (exceptionHandler == null)) { + ExceptionHandler candidate = (ExceptionHandler) iter.next(); + if (candidate.matches(exception)) { exceptionHandler = candidate; } } @@ -487,20 +438,17 @@ return exceptionHandler; } - public GraphElement getParent() - { + public GraphElement getParent() { return processDefinition; } /** * @return all the parents of this graph element ordered by age. */ - public List getParents() - { + public List getParents() { List parents = new ArrayList(); GraphElement parent = getParent(); - if (parent != null) - { + if (parent != null) { parent.addParentChain(parents); } return parents; @@ -509,33 +457,26 @@ /** * @return this graph element plus all the parents ordered by age. */ - public List getParentChain() - { + public List getParentChain() { List parents = new ArrayList(); this.addParentChain(parents); return parents; } - void addParentChain(List parentChain) - { + void addParentChain(List parentChain) { parentChain.add(this); GraphElement parent = getParent(); - if (parent != null) - { + if (parent != null) { parent.addParentChain(parentChain); } } - public String toString() - { + public String toString() { String className = getClass().getName(); className = className.substring(className.lastIndexOf('.') + 1); - if (name != null) - { + if (name != null) { className = className + "(" + name + ")"; - } - else - { + } else { className = className + "(" + Integer.toHexString(System.identityHashCode(this)) + ")"; } return className; @@ -544,45 +485,37 @@ // equals /////////////////////////////////////////////////////////////////// // hack to support comparing hibernate proxies against the real objects // since this always falls back to ==, we don't need to overwrite the hashcode - public boolean equals(Object o) - { + public boolean equals(Object o) { return EqualsUtil.equals(this, o); } // getters and setters ////////////////////////////////////////////////////// - public long getId() - { + public long getId() { return id; } - public String getName() - { + public String getName() { return name; } - public void setName(String name) - { + public void setName(String name) { this.name = name; } - public String getDescription() - { + public String getDescription() { return description; } - public void setDescription(String description) - { + public void setDescription(String description) { this.description = description; } - public ProcessDefinition getProcessDefinition() - { + public ProcessDefinition getProcessDefinition() { return processDefinition; } - public void setProcessDefinition(ProcessDefinition processDefinition) - { + public void setProcessDefinition(ProcessDefinition processDefinition) { this.processDefinition = processDefinition; } Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/PersistenceService.java =================================================================== --- jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/PersistenceService.java 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/PersistenceService.java 2008-12-23 13:31:21 UTC (rev 3535) @@ -38,8 +38,17 @@ ContextSession getContextSession(); TaskMgmtSession getTaskMgmtSession(); + /** + * @deprecated use {@link org.jbpm.tx.TxService} instead. + */ boolean isRollbackOnly(); + /** + * @deprecated use {@link org.jbpm.tx.TxService} instead. + */ void setRollbackOnly(boolean isRollbackOnly); + /** + * @deprecated use {@link org.jbpm.tx.TxService} instead. + */ void setRollbackOnly(); void setGraphSession(GraphSession graphSession); Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/db/DbPersistenceService.java =================================================================== --- jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/db/DbPersistenceService.java 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/db/DbPersistenceService.java 2008-12-23 13:31:21 UTC (rev 3535) @@ -197,17 +197,21 @@ return connection; } - protected boolean isTransactionActive() { - return (isTransactionEnabled && (transaction != null)) ; + public boolean isTransactionActive() { + return transaction != null && transaction.isActive(); } - + + protected boolean isTransactionExternallyManaged() { + return !(isTransactionEnabled && transaction != null); + } + public void close() { if ( (session!=null) - && !isTransactionActive() + && isTransactionExternallyManaged() && (isRollbackOnly()) ) { - throw new JbpmException("setRollbackOnly was invoked while configuration specifies user managed transactions"); + throw new JbpmException("setRollbackOnly was invoked while transaction is being managed externally"); } if ( (isTransactionEnabled) @@ -235,8 +239,8 @@ Exception flushException = flushSession(); if (flushException!=null) { - // JBPM-1465 transaction has been either committed or rolled back at this point - // on the other hand, it is possible that no transaction is underway + // JBPM-1465: transaction is either committed or rolled back at this point; + // it is also possible that the transaction was initiated externally // hence rolling back here is redundant and possibly dangerous closeSession(); closeConnection(); Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/jta/JtaDbPersistenceService.java =================================================================== --- jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/jta/JtaDbPersistenceService.java 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/persistence/jta/JtaDbPersistenceService.java 2008-12-23 13:31:21 UTC (rev 3535) @@ -30,33 +30,36 @@ import org.hibernate.util.JTAHelper; import org.jbpm.JbpmException; import org.jbpm.persistence.db.DbPersistenceService; -import org.jbpm.persistence.db.DbPersistenceServiceFactory; public class JtaDbPersistenceService extends DbPersistenceService { private static final long serialVersionUID = 1L; - - private static Log log = LogFactory.getLog(JtaDbPersistenceService.class); - + + private static Log log = LogFactory.getLog(JtaDbPersistenceService.class); + private UserTransaction userTransaction; - public JtaDbPersistenceService(DbPersistenceServiceFactory persistenceServiceFactory) { + public JtaDbPersistenceService(JtaDbPersistenceServiceFactory persistenceServiceFactory) { super(persistenceServiceFactory); - + if (!isJtaTransactionInProgress()) { - beginJtaTransaction(); + beginUserTransaction(); } } - protected boolean isTransactionActive() { + public boolean isTransactionActive() { return isJtaTransactionInProgress(); } - + + protected boolean isTransactionExternallyManaged() { + return !isJtaTxCreated(); + } + public void close() { super.close(); if (userTransaction != null) { - endJtaTransaction(); + endUserTransaction(); } } @@ -65,18 +68,19 @@ return JTAHelper.isTransactionInProgress(sessionFactory); } - void beginJtaTransaction() { + void beginUserTransaction() { try { log.debug("begin user transaction"); - userTransaction = ((JtaDbPersistenceServiceFactory) persistenceServiceFactory).getUserTransaction(); + userTransaction = ((JtaDbPersistenceServiceFactory) persistenceServiceFactory) + .getUserTransaction(); userTransaction.begin(); } catch (Exception e) { throw new JbpmException("couldn't begin user transaction", e); } } - void endJtaTransaction() { - if (isRollbackOnly() || JTAHelper.isRollback(getJtaTransactionStatus())) { + void endUserTransaction() { + if (isRollbackOnly() || JTAHelper.isRollback(getUserTransactionStatus())) { log.debug("rolling back user transaction"); try { userTransaction.rollback(); @@ -93,11 +97,11 @@ } } - int getJtaTransactionStatus() { + int getUserTransactionStatus() { try { return userTransaction.getStatus(); } catch (SystemException e) { - throw new JbpmException("couldn't get status for user transaction", e); + throw new JbpmException("couldn't get status for user transaction", e); } } Modified: jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/ProcessDefinition.hbm.xml =================================================================== --- jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/ProcessDefinition.hbm.xml 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/ProcessDefinition.hbm.xml 2008-12-23 13:31:21 UTC (rev 3535) @@ -19,7 +19,7 @@ <index column="EVENTTYPE_" type="string"/> <one-to-many class="org.jbpm.graph.def.Event" /> </map> - <list name="exceptionHandlers" cascade="all" lazy="false"> + <list name="exceptionHandlers" cascade="all"> <key column="PROCESSDEFINITION_" foreign-key="none" /> <list-index column="GRAPHELEMENTINDEX_" /> <one-to-many class="org.jbpm.graph.def.ExceptionHandler" /> Modified: jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/Transition.hbm.xml =================================================================== --- jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/Transition.hbm.xml 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/resources/org/jbpm/graph/def/Transition.hbm.xml 2008-12-23 13:31:21 UTC (rev 3535) @@ -20,7 +20,7 @@ <index column="EVENTTYPE_" type="string" /> <one-to-many class="org.jbpm.graph.def.Event" /> </map> - <list name="exceptionHandlers" cascade="all" lazy="false"> + <list name="exceptionHandlers" cascade="all"> <key column="TRANSITION_" foreign-key="none" /> <list-index column="GRAPHELEMENTINDEX_" /> <one-to-many class="org.jbpm.graph.def.ExceptionHandler" /> Modified: jbpm3/trunk/modules/core/src/main/resources/org/jbpm/taskmgmt/def/Task.hbm.xml =================================================================== --- jbpm3/trunk/modules/core/src/main/resources/org/jbpm/taskmgmt/def/Task.hbm.xml 2008-12-23 12:43:49 UTC (rev 3534) +++ jbpm3/trunk/modules/core/src/main/resources/org/jbpm/taskmgmt/def/Task.hbm.xml 2008-12-23 13:31:21 UTC (rev 3535) @@ -22,7 +22,7 @@ <index column="EVENTTYPE_" type="string"/> <one-to-many class="org.jbpm.graph.def.Event" /> </map> - <list name="exceptionHandlers" cascade="all" lazy="false"> + <list name="exceptionHandlers" cascade="all"> <key column="TASK_" foreign-key="none" /> <list-index column="GRAPHELEMENTINDEX_" /> <one-to-many class="org.jbpm.graph.def.ExceptionHandler" /> Added: jbpm3/trunk/modules/core/src/test/java/org/jbpm/jbpm1775/JBPM1775Test.java =================================================================== --- jbpm3/trunk/modules/core/src/test/java/org/jbpm/jbpm1775/JBPM1775Test.java (rev 0) +++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/jbpm1775/JBPM1775Test.java 2008-12-23 13:31:21 UTC (rev 3535) @@ -0,0 +1,87 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2005, JBoss Inc., and individual contributors as indicated + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jbpm.jbpm1775; + +import org.jbpm.JbpmException; +import org.jbpm.db.AbstractDbTestCase; +import org.jbpm.graph.def.ActionHandler; +import org.jbpm.graph.def.DelegationException; +import org.jbpm.graph.def.ProcessDefinition; +import org.jbpm.graph.exe.ExecutionContext; +import org.jbpm.graph.exe.ProcessInstance; +import org.jbpm.persistence.db.DbPersistenceService; + +/** + * Verify if exception handlers collection can be loaded lazily. + * + * @see <a href="https://jira.jboss.org/jira/browse/JBPM-1775">JBPM-177... + * @author Alejandro Guizar + */ +public class JBPM1775Test extends AbstractDbTestCase { + + public void testExceptionInAction() { + ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<?xml version='1.0'?>" + + "<process-definition name='" + + getName() + + "'>" + + " <exception-handler exception-class='java.lang.IllegalStateException'>" + + " <action class='org.example.NoSuchAction' />" + + " </exception-handler>" + + " <start-state name='start'>" + + " <transition to='end'>" + + " <action class='" + + ExceptionAction.class.getName() + + "' />" + + " </transition>" + + " </start-state>" + + " <end-state name='end' />" + + "</process-definition>"); + jbpmContext.deployProcessDefinition(processDefinition); + try { + ProcessInstance processInstance = jbpmContext.newProcessInstance(processDefinition.getName()); + processInstance.signal(); + fail("expected delegation exception"); + } catch (DelegationException e) { + assertSame(IllegalStateException.class, e.getCause().getClass()); + try { + closeJbpmContext(); + } catch (JbpmException je) { + // discard failure to close normally + } + beginSessionTransaction(); + } + } + + public static class ExceptionAction implements ActionHandler { + private static final long serialVersionUID = 1L; + + public void execute(ExecutionContext executionContext) throws Exception { + // NOTE that manipulating the hibernate transaction directly is bad practice + // use JbpmContext or TxService instead! + DbPersistenceService persistenceService = (DbPersistenceService) executionContext + .getJbpmContext().getServices().getPersistenceService(); + persistenceService.getTransaction().rollback(); + // throw exception + throw new IllegalStateException("transaction was forcefully rolled back"); + } + } +}